Environment

4719 references to Environment

AksDemo.ApiService (11)

Program.cs (11)

21machineName = Environment.MachineName, 22podIp = Environment.GetEnvironmentVariable("POD_IP"), 37machineName = Environment.MachineName 42machineName = Environment.MachineName, 43osVersion = Environment.OSVersion.ToString(), 44processorCount = Environment.ProcessorCount, 45dotnetVersion = Environment.Version.ToString(), 46aspnetcoreEnv = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"), 47podIp = Environment.GetEnvironmentVariable("POD_IP"), 48podName = Environment.GetEnvironmentVariable("POD_NAME"), 49nodeName = Environment.GetEnvironmentVariable("NODE_NAME")

aspire (148)

Acquisition\InstallationDiscovery.cs (4)

64=> DescribeSelf(Environment.ProcessPath, pathHits: null); 70/// without manipulating <see cref="Environment.ProcessPath"/>. 117=> DiscoverAllAsync(Environment.ProcessPath, cancellationToken); 123/// manipulating <see cref="Environment.ProcessPath"/> globally.

Acquisition\WingetFirstRunProbe.cs (1)

47var processPath = Environment.ProcessPath;

Backchannel\AppHostConnectionResolver.cs (1)

149Environment.ProcessId,

Backchannel\AuxiliaryBackchannelMonitor.cs (1)

373var currentSockets = AppHostSocketManager.FindSockets(executionContext.HomeDirectory.FullName, Environment.ProcessId, logger);

Bundles\BundleService.cs (6)

67/// Overrides <see cref="Environment.ProcessPath"/> for version fingerprinting. 200var processPath = ProcessPathOverride ?? Environment.ProcessPath; 341var badPath = $"{activeVersionDir}{BadSuffixPrefix}{Environment.TickCount64}"; 380var badPath = $"{activeVersionDir}{BadSuffixPrefix}{Environment.TickCount64}"; 529var renamedPath = $"{linkPath}.old.{Environment.TickCount64}"; 800processPath ??= Environment.ProcessPath;

Caching\AppHostInfoDiskCache.cs (1)

260var startDirectory = projectFile.Directory ?? new DirectoryInfo(Environment.CurrentDirectory);

Certificates\CertificateGeneration\CertificateManager.cs (1)

1040return string.Join(Environment.NewLine, description);

Certificates\CertificateGeneration\MacOSCertificateManager.cs (4)

28private static readonly string s_macOSUserKeychain = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "/Library/Keychains/login.keychain-db"; 36private static readonly string s_macOSUserHttpsCertificateLocation = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".aspnet", "dev-certs", "https");

Certificates\CertificateGeneration\UnixCertificateManager.cs (7)

160var nssDbs = GetNssDbs(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)); 257var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 488var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)!; 878Log.UnixHomeDirectoryDoesNotExist(homeDirectory, Environment.UserName);

Certificates\CertificateHelpers.cs (4)

33Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 39Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),

CliExecutionContext.cs (2)

165public DirectoryInfo HomeDirectory { get; } = homeDirectory ?? new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile));

Commands\AgentInitCommand.cs (1)

721var message = string.Join(Environment.NewLine,

Commands\AppHostLauncher.cs (3)

310Environment.ProcessId, 356var dotnetPath = Environment.ProcessPath ?? "dotnet"; 360var entryAssemblyPath = Environment.GetCommandLineArgs().FirstOrDefault();

Commands\InstallationInfoOutput.cs (2)

117var processPath = Environment.ProcessPath; 211Path = Environment.ProcessPath ?? string.Empty,

Commands\ResourceCommand.cs (1)

324return (arguments, string.Join(Environment.NewLine, parseResult.Errors.Select(static error => error.Message)));

Commands\ResourceCommandHelper.cs (6)

103interactionService.DisplayError($"Failed to validate command arguments for command '{commandName}' on resource '{resourceName}':{Environment.NewLine}{errorMessage}"); 146interactionService.DisplayError($"Failed to validate command arguments for command '{commandName}' on resource '{resourceName}':{Environment.NewLine}{errorMessage}"); 188return $"{errorMessage}{Environment.NewLine}{string.Join(Environment.NewLine, errors)}"; 198var errors = string.Join(Environment.NewLine, validationErrors.Select(error => $"{FormatArgumentNameForDisplay(error.ArgumentName)}: {error.ErrorMessage}")); 201: $"{errorMessage}{Environment.NewLine}{errors}";

Commands\RunCommand.cs (1)

1292: $"{entry.Message}{Environment.NewLine}{entry.Exception}";

Commands\SetupCommand.cs (1)

47var processPath = Environment.ProcessPath;

Commands\TerminalAttachCommand.cs (1)

183"aspire-cli:{0}", Environment.ProcessId);

Commands\UpdateCommand.cs (1)

882var pathEnv = Environment.GetEnvironmentVariable("PATH");

Diagnostics\FileLoggerProvider.cs (1)

180? $"[{ts}] [{lvl}] [{category}] {message}{Environment.NewLine}{exception}"

DotNet\DotNetCliRunner.cs (4)

366return $"{timestamp}-{Environment.ProcessId}-{sequence:D4}-{SanitizeFileNamePart(dotnetCommand)}-{SanitizeFileNamePart(scope)}.binlog"; 613var processPath = Environment.ProcessPath; 1216var lines = stdout.Split(Environment.NewLine); 1260workingDirectory: new DirectoryInfo(Environment.CurrentDirectory),

HostEnvironment.cs (2)

14public string? GetEnvironmentVariable(string variable) => Environment.GetEnvironmentVariable(variable); 18return Environment.GetEnvironmentVariables()

Layout\LayoutDiscovery.cs (2)

49/// Overrides <see cref="Environment.ProcessPath"/> for relative-layout discovery. 187var cliPath = ProcessPathOverride ?? Environment.ProcessPath;

Mcp\Tools\ExecuteResourceCommandTool.cs (2)

142message = $"{message}{Environment.NewLine}{string.Join(Environment.NewLine, response.ValidationErrors.Select(error => $"{ResourceCommandHelper.FormatArgumentNameForDisplay(error.ArgumentName)}: {error.ErrorMessage}"))}";

Packaging\PackagingService.cs (1)

117_processPathProvider = processPathProvider ?? (() => Environment.ProcessPath);

Packaging\TemporaryNuGetConfig.cs (2)

72NewLineChars = Environment.NewLine, 146: $"{document.Declaration}{Environment.NewLine}{document}";

Processes\IsolatedProcess.Unix.cs (1)

33dcpStartInfo.ArgumentList.Add(Environment.ProcessId.ToString(CultureInfo.InvariantCulture));

Processes\OrphanDetectionEnvironment.cs (1)

37Apply((IDictionary<string, string?>)environment, Environment.ProcessId, ProcessStartTimeHelper.GetCurrentProcessStartTimeUnixMilliseconds(), pidKey, startedKey, overwrite);

Processes\ProcessEnvironment.cs (1)

18var parent = Environment.GetEnvironmentVariables();

Profiling\ProfileCaptureEnvironment.cs (4)

32previousValues[name] = Environment.GetEnvironmentVariable(name); 33Environment.SetEnvironmentVariable(name, value); 45if (Environment.GetEnvironmentVariable(name) is { } value) 56Environment.SetEnvironmentVariable(name, value);

Program.cs (8)

65return CliPathHelper.GetAspireHomeDirectory(processPath ?? Environment.ProcessPath); 311var workingDirectory = new DirectoryInfo(Environment.CurrentDirectory); 706var workingDirectory = new DirectoryInfo(Environment.CurrentDirectory); 1043var profileCaptureOptions = ProfileCaptureOptions.TryCreate(args, TimeProvider.System, new DirectoryInfo(Environment.CurrentDirectory)); 1059logger.LogInformation("Aspire CLI path: {CliPath}", Environment.ProcessPath); 1068logger.LogInformation("Working directory: {WorkingDirectory}", Environment.CurrentDirectory); 1072logger.LogInformation("CLI process ID: {ProcessId}", Environment.ProcessId); 1331string.Format(CultureInfo.CurrentCulture, RootCommandStrings.WaitingForDebugger, Environment.ProcessId),

Projects\AppHostEnvironmentDefaults.cs (1)

157var value = Environment.GetEnvironmentVariable(variableName);

Projects\AppHostServerSession.cs (1)

204Environment.ProcessId,

Projects\DotNetAppHostProject.cs (4)

1878var startDirectory = effectiveAppHostFile.Directory ?? new DirectoryInfo(Environment.CurrentDirectory); 2055env[name] = Environment.ExpandEnvironmentVariables(value); 2063AppendParsedArguments(Environment.ExpandEnvironmentVariables(profile.CommandLineArgs), arguments); 2518Environment.ProcessId,

Projects\DotNetBasedAppHostServerProject.cs (2)

762var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Projects\GuestAppHostProject.cs (1)

1624Environment.ProcessId,

Projects\JavaAppHostToolchainResolver.cs (2)

348Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe", 447var temporaryPath = $"{scriptPath}.{Environment.ProcessId}.tmp";

Projects\PrebuiltAppHostServer.cs (2)

802string.Join(Environment.NewLine, buildOutput.GetLines().Select(l => l.Line))); 808var outputLines = string.Join(Environment.NewLine, buildOutput.GetLines().Select(l => l.Line));

Projects\ProjectLocator.cs (1)

322MaxDegreeOfParallelism = Environment.ProcessorCount

Projects\ProjectUpdater.cs (5)

211if (Environment.OSVersion.Platform == PlatformID.Win32NT) 213return path.StartsWith(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), StringComparison.Ordinal); 217var globalNuGetFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".nuget");

Projects\TypeScriptAppHostToolchainResolver.cs (2)

509homeDirectory ??= Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

src\Shared\AspireHomeDirectory.cs (3)

22Environment.GetEnvironmentVariable(EnvironmentVariable), 23Environment.GetFolderPath(Environment.SpecialFolder.UserProfile));

src\Shared\BundleDiscovery.cs (1)

375var processPath = Environment.ProcessPath;

src\Shared\BundleVersionLease.cs (3)

116Environment.ProcessId, 140var versionDirectory = Environment.GetEnvironmentVariable(BundleDiscovery.BundleVersionDirectoryEnvVar); 206$"{Environment.ProcessId}-{startTicks}-");

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

79var value = string.Join(Environment.NewLine, uniqueLines);

src\Shared\PathLookupHelper.cs (6)

35var path = pathOverride ?? Environment.GetEnvironmentVariable("PATH"); 37? (pathExtensionsOverride ?? Environment.GetEnvironmentVariable("PATHEXT"))?.Split(';', StringSplitOptions.RemoveEmptyEntries) ?? [] 81? Environment.GetEnvironmentVariable("PATHEXT")?.Split(';', StringSplitOptions.RemoveEmptyEntries) ?? [] 84return FindFullPathFromPath(command, Environment.GetEnvironmentVariable("PATH"), Path.PathSeparator, FileExistsAndIsExecutable, pathExtensions); 95? Environment.GetEnvironmentVariable("PATHEXT")?.Split(';', StringSplitOptions.RemoveEmptyEntries) ?? [] 98return FindAllFullPathsFromPath(command, Environment.GetEnvironmentVariable("PATH"), Path.PathSeparator, FileExistsAndIsExecutable, pathExtensions);

src\Shared\ProcessStartTimeHelper.cs (1)

62if (TryGetProcessStartTime(Environment.ProcessId) is { } startTime)

src\Shared\UserSecrets\UserSecretsPathHelper.cs (7)

34string? appData = Environment.GetEnvironmentVariable("APPDATA"); 36?? Environment.GetEnvironmentVariable("HOME") // On Mac/Linux it goes to ~/.microsoft/usersecrets/ 37?? Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) 38?? Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) 39?? Environment.GetEnvironmentVariable(userSecretsFallbackDir); // this fallback is an escape hatch if everything else fails

Telemetry\AspireCliTelemetry.cs (1)

366tagsList.Add(new(TelemetryConstants.Tags.OsVersion, Environment.OSVersion.Version.ToString()));

Telemetry\InternalMicrosoftDetector.cs (4)

622var localAppData = GetSpecialFolderPath(Environment.SpecialFolder.LocalApplicationData, "LOCALAPPDATA"); 682return EvaluateMacPlatformSso($"{result.Stdout}{Environment.NewLine}{result.Stderr}"); 1632private string GetSpecialFolderPath(Environment.SpecialFolder folder, string environmentVariableName) 1635Environment.GetFolderPath(folder);

Telemetry\LinuxMachineInformationProvider.cs (3)

24var userDir = Environment.GetEnvironmentVariable(PrimaryPathEnvVar); 29var rootPath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Telemetry\MacOSXMachineInformationProvider.cs (4)

20/// user's profile directory using <see cref="Environment.SpecialFolder.UserProfile"/>. If that is unavailable, it 30var userDir = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 35userDir = Environment.GetEnvironmentVariable("HOME");

Telemetry\TelemetryManager.cs (2)

237var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Utils\AspireRepositoryDetector.cs (2)

68var envRoot = Environment.GetEnvironmentVariable(BundleDiscovery.RepoRootEnvVar); 74var processPath = Environment.ProcessPath;

Utils\CliPathHelper.cs (4)

46var effectiveProcessPath = processPath ?? Environment.ProcessPath; 220/// returns <see langword="null"/>. Meanwhile, <see cref="Environment.ProcessPath"/> 347var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Utils\EnvironmentChecker\DcpConnectionChecker.cs (2)

392Environment.NewLine, 407return lines.Length == 0 ? DoctorCommandStrings.DcpNoOutputDetails : string.Join(Environment.NewLine, lines);

Utils\EnvironmentChecker\OperatingSystemCheck.cs (1)

58var version = Environment.OSVersion.Version;

Utils\FileDeleteHelper.cs (2)

46var renamedPath = $"{path}.old.{Environment.TickCount64}"; 82var renamedPath = $"{path}.old.{Environment.TickCount64}";

Utils\IProcessPathProvider.cs (1)

16public string? ProcessPath => Environment.ProcessPath;

Utils\NpmInstallDetection.cs (1)

90return Environment.GetEnvironmentVariable(name);

aspire-managed (13)

NuGet\Commands\NuGetPackageAssetResolver.cs (2)

126Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),

NuGet\Commands\RestoreCommand.cs (2)

192DisableParallel = Environment.ProcessorCount == 1, 212var errors = string.Join(Environment.NewLine,

NuGet\TrustedRootsHelper.cs (1)

47var envValue = Environment.GetEnvironmentVariable("DOTNET_NUGET_SIGNATURE_VERIFICATION");

src\Shared\BundleDiscovery.cs (1)

375var processPath = Environment.ProcessPath;

src\Shared\BundleVersionLease.cs (3)

116Environment.ProcessId, 140var versionDirectory = Environment.GetEnvironmentVariable(BundleDiscovery.BundleVersionDirectoryEnvVar); 206$"{Environment.ProcessId}-{startTicks}-");

src\Shared\ParentProcessWatchdog.cs (3)

47if (!int.TryParse(Environment.GetEnvironmentVariable(processIdVariable), NumberStyles.Integer, CultureInfo.InvariantCulture, out var parentPid)) 53Environment.GetEnvironmentVariable, 61stopToken => CancelAndForceExitAsync(operationCts, stopToken, ForceExitGracePeriod, Environment.Exit),

src\Shared\ProcessStartTimeHelper.cs (1)

62if (TryGetProcessStartTime(Environment.ProcessId) is { } startTime)

Aspire.Acquisition.Tests (31)

Scripts\Common\RealGitHubPRFixture.cs (2)

45var ghToken = Environment.GetEnvironmentVariable("GH_TOKEN"); 200return string.Join(Environment.NewLine, stdoutLines);

Scripts\PRScriptFunctionTests.cs (3)

302cmd.WithEnvironmentVariable("PATH", $"{mockBinDir}:{Environment.GetEnvironmentVariable("PATH")}"); 326cmd.WithEnvironmentVariable("PATH", $"{mockBinDir}:{Environment.GetEnvironmentVariable("PATH")}"); 349cmd.WithEnvironmentVariable("PATH", $"{mockBinDir}:{Environment.GetEnvironmentVariable("PATH")}");

Scripts\PRScriptInstallE2ETests.cs (1)

39cmd.WithEnvironmentVariable("PATH", $"{mockGhPath}{Path.PathSeparator}{Environment.GetEnvironmentVariable("PATH")}");

Scripts\PRScriptInstallerModeTests.cs (7)

Scripts\PRScriptPowerShellTests.cs (1)

27cmd.WithEnvironmentVariable("PATH", $"{mockGhPath}{Path.PathSeparator}{Environment.GetEnvironmentVariable("PATH")}");

Scripts\PRScriptShellTests.cs (1)

25cmd.WithEnvironmentVariable("PATH", $"{mockGhPath}{Path.PathSeparator}{Environment.GetEnvironmentVariable("PATH")}");

Scripts\PRScriptToolModeTests.cs (11)

Scripts\ReleaseScriptFunctionTests.cs (2)

634cmd.WithEnvironmentVariable("PATH", $"{mockBinDir}:{Environment.GetEnvironmentVariable("PATH")}"); 671cmd.WithEnvironmentVariable("PATH", $"{mockBinDir}:{Environment.GetEnvironmentVariable("PATH")}");

tests\Shared\TemplatesTesting\CommandResult.cs (2)

32_ = message.AppendLine(CultureInfo.InvariantCulture, $"{Environment.NewLine}Standard Output:{Environment.NewLine}{Output}");

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

203return string.Join(System.Environment.NewLine, outputLines);

Aspire.Azure.AI.Inference (4)

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

16Environment.GetEnvironmentVariable(KnownOtelConfigNames.InstrumentationGenAiCaptureMessageContent) is string envVar &&

src\Shared\AzureCredentialHelper.cs (3)

16if (Environment.GetEnvironmentVariable(DefaultAzureCredential.DefaultEnvironmentVariableName) is not null) 21if (Environment.GetEnvironmentVariable("AZURE_CLIENT_ID") is string azureClientId) 30else if (Environment.GetEnvironmentVariable("IDENTITY_ENDPOINT") is not null)

Aspire.Azure.AI.OpenAI (4)

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

16Environment.GetEnvironmentVariable(KnownOtelConfigNames.InstrumentationGenAiCaptureMessageContent) is string envVar &&

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Azure.Messaging.EventHubs (5)

AzureMessagingEventHubsSettings.cs (1)

83var envVar = Environment.GetEnvironmentVariable("AZURE_EXPERIMENTAL_ENABLE_ACTIVITY_SOURCE");

EventHubsComponent.cs (1)

80var identifier = $"{Environment.MachineName}-{eventHubName}-" +

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Azure.Messaging.ServiceBus (1)

AzureMessagingServiceBusSettings.cs (1)

83var envVar = Environment.GetEnvironmentVariable("AZURE_EXPERIMENTAL_ENABLE_ACTIVITY_SOURCE");

Aspire.Azure.Npgsql (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Azure.Npgsql.EntityFrameworkCore.PostgreSQL (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Azure.Search.Documents (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Azure.Security.KeyVault (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Cli.EndToEnd.Tests (69)

DotnetToolSmokeTests.cs (4)

119var source = Environment.GetEnvironmentVariable("ASPIRE_E2E_DOTNET_TOOL_SOURCE"); 123var version = Environment.GetEnvironmentVariable("ASPIRE_E2E_VERSION"); 132var builtNugetsPath = Environment.GetEnvironmentVariable("BUILT_NUGETS_PATH"); 141var requestedVersion = Environment.GetEnvironmentVariable("ASPIRE_E2E_VERSION");

Helpers\CliE2ETestHelpers.cs (17)

Helpers\CliInstallStrategyTests.cs (3)

1023variable => Environment.GetEnvironmentVariable(variable.Name)); 1027Environment.SetEnvironmentVariable(name, value); 1035Environment.SetEnvironmentVariable(name, value);

Helpers\KubernetesDeployTestHelpers.cs (2)

469Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "bin", "kind");

Helpers\KubernetesE2EVersions.cs (4)

28public static string KindVersion => Environment.GetEnvironmentVariable("KIND_VERSION") ?? "v0.31.0"; 30public static string HelmVersion => Environment.GetEnvironmentVariable("HELM_VERSION") ?? "v4.2.0"; 32public static string KubectlVersion => Environment.GetEnvironmentVariable("KUBECTL_VERSION") ?? "v1.34.3"; 44public static string RadiusVersion => Environment.GetEnvironmentVariable("RADIUS_VERSION") ?? "0.59.0";

Helpers\TypeScriptAppHostToolchainTestHelpers.cs (2)

41File.WriteAllText(packageJsonPath, $"{packageJson.ToJsonString(s_packageJsonSerializerOptions)}{Environment.NewLine}"); 183File.WriteAllText(yarnConfigPath, $"{YarnNodeModulesConfiguration}{Environment.NewLine}");

KubernetesPublishRequiresExternalEndpointTests.cs (1)

95content = content.Replace(buildRunPattern, appHostBodyExtension + Environment.NewLine + buildRunPattern);

KubernetesPublishTests.cs (2)

299cleanupProcess.StartInfo.FileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "bin", "kind");

OllamaIntegrationTests.cs (2)

59output.WriteLine($"Original AppHost.cs content:{Environment.NewLine}{content}"); 69output.WriteLine($"Modified AppHost.cs content:{Environment.NewLine}{content}");

ProjectReferenceTests.cs (2)

73Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".aspire");

RadiusDeployTests.cs (2)

128content = content.Replace(buildRunPattern, radiusWiring + Environment.NewLine + Environment.NewLine + buildRunPattern);

RadiusPublishTests.cs (2)

93content = content.Replace(buildRunPattern, radiusWiring + Environment.NewLine + Environment.NewLine + buildRunPattern);

tests\Shared\CliInstallStrategy.cs (21)

tests\Shared\Hex1bAutomatorTestHelpers.cs (2)

838$"(not a product failure). Terminal output:{Environment.NewLine}{terminalOutput}"); 841throw new InvalidOperationException($"Pipeline failed unexpectedly. Terminal output:{Environment.NewLine}{terminalOutput}");

tests\Shared\Hex1bTestHelpers.cs (1)

120var githubWorkspace = Environment.GetEnvironmentVariable("GITHUB_WORKSPACE");

TypeScriptPolyglotTests.cs (2)

387File.AppendAllText(appHostPath, $"{Environment.NewLine}// Trigger Deno watch restart.{Environment.NewLine}");

Aspire.Cli.Tests (234)

Acquisition\InstallationDiscoveryDiscoverAllTests.cs (7)

44using var _ = new EnvVarOverride("PATH", pathDir + Path.PathSeparator + (Environment.GetEnvironmentVariable("PATH") ?? string.Empty)); 336using var _ = new EnvVarOverride("PATH", binDir + Path.PathSeparator + (Environment.GetEnvironmentVariable("PATH") ?? string.Empty)); 578using var _ = new EnvVarOverride("PATH", pathDir + Path.PathSeparator + (Environment.GetEnvironmentVariable("PATH") ?? string.Empty)); 856binDir + Path.PathSeparator + (Environment.GetEnvironmentVariable("PATH") ?? string.Empty)); 954var path = Environment.ProcessPath!; 984/// <see cref="Environment.GetFolderPath(Environment.SpecialFolder)"/>

Acquisition\PeerInstallProbeTests.cs (1)

38Assert.Fail($"Expected PeerProbeResult.Ok, got PeerProbeResult.Failed. Reason:{Environment.NewLine}{failed.Reason}");

Backchannel\AppHostAuxiliaryBackchannelTests.cs (1)

177private readonly int _processId = Environment.ProcessId;

Backchannel\AppHostConnectionResolverTests.cs (1)

535ProcessId = Environment.ProcessId

Backchannel\AuxiliaryBackchannelMonitorTests.cs (3)

249$"Saw {CountConnectAttempts(logger, socketPath)}. Captured log:{Environment.NewLine}" + 250string.Join(Environment.NewLine, logger.Entries.Select(entry => $" [{entry.Level}/{entry.EventId}] {entry.Message}"))); 290var socketPath = Path.Combine(backchannelsDirectory, $"{appHostId}a1b2C3d4.{Environment.ProcessId}");

Backchannel\BackchannelConstantsTests.cs (3)

211var currentPid = Environment.ProcessId; 353var currentPid = Environment.ProcessId; 402var currentPid = Environment.ProcessId;

Backchannel\OrphanedAppHostCollectorTests.cs (6)

50CliProcessId = Environment.ProcessId, 70CliProcessId = Environment.ProcessId, 90CliProcessId = Environment.ProcessId, 110CliProcessId = Environment.ProcessId, 131CliProcessId = Environment.ProcessId, 383CliProcessId = Environment.ProcessId,

BundleServiceIntegrationTests.cs (4)

329if (OperatingSystem.IsWindows() || Environment.IsPrivilegedProcess) 459var originalAspireHome = Environment.GetEnvironmentVariable(CliPathHelper.AspireHomeEnvironmentVariable); 462Environment.SetEnvironmentVariable(CliPathHelper.AspireHomeEnvironmentVariable, aspireHome); 504Environment.SetEnvironmentVariable(CliPathHelper.AspireHomeEnvironmentVariable, originalAspireHome);

Certificates\CertificateProcessRunnerTests.cs (2)

33var expectedStandardOutput = string.Concat(Enumerable.Repeat(StandardOutputLine + Environment.NewLine, LineCount)); 34var expectedStandardError = string.Concat(Enumerable.Repeat(StandardErrorLine + Environment.NewLine, LineCount));

Certificates\UnixCertificateManagerTests.cs (11)

CliBootstrapTests.cs (1)

236var expectedStatus = string.Format(CultureInfo.CurrentCulture, RootCommandStrings.WaitingForDebugger, Environment.ProcessId);

CliSmokeTests.cs (8)

42Environment.SetEnvironmentVariable(envVar, loc); 44Environment.SetEnvironmentVariable(Aspire.Cli.CliConfigNames.NoLogo, "true"); 46Environment.SetEnvironmentVariable(envVar, null); 47Environment.SetEnvironmentVariable(Aspire.Cli.CliConfigNames.NoLogo, null); 51var lines = errorOutput.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 89var lines = errorOutput.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 138Environment.SetEnvironmentVariable(CliConfigNames.NoLogo, "true"); 142Environment.SetEnvironmentVariable(CliConfigNames.NoLogo, null);

Commands\AgentInitCommandTests.cs (2)

50var expectedSummary = string.Join(Environment.NewLine, 84var expectedSummary = string.Join(Environment.NewLine,

Commands\AppHostLauncherTests.cs (8)

Commands\DescribeCommandTests.cs (2)

623connection.AppHostInfo = CreateAppHostInfo(workspace, Environment.ProcessId); 677connection.AppHostInfo = CreateAppHostInfo(workspace, Environment.ProcessId);

Commands\DoctorCommandTests.cs (2)

802Assert.True(summaryIndex >= 0, $"Expected doctor summary in output:{Environment.NewLine}{rendered}"); 803Assert.True(installationsIndex > summaryIndex, $"Expected installations after summary in output:{Environment.NewLine}{rendered}");

Commands\LogsCommandTests.cs (4)

910connection.AppHostInfo = CreateAppHostInfo(workspace, Environment.ProcessId); 955connection.AppHostInfo = CreateAppHostInfo(workspace, Environment.ProcessId); 1409connection.AppHostInfo = CreateAppHostInfo(workspace, Environment.ProcessId); 1447connection.AppHostInfo = CreateAppHostInfo(workspace, Environment.ProcessId);

Commands\PsCommandTests.cs (5)

386var output = string.Join(Environment.NewLine, textWriter.Logs); 387var normalizedOutput = output.Replace(Environment.NewLine, string.Empty, StringComparison.Ordinal); 419var output = string.Join(Environment.NewLine, textWriter.Logs); 420var normalizedOutput = output.Replace(Environment.NewLine, string.Empty, StringComparison.Ordinal); 460var output = string.Join(Environment.NewLine, textWriter.Logs);

Commands\RootCommandTests.cs (1)

226var help = string.Join(Environment.NewLine, outputWriter.Logs);

Commands\RunCommandTests.cs (1)

4498Assert.Contains($"Error message{Environment.NewLine}System.InvalidOperationException: boom", logFileContents);

Commands\Sdk\SdkExportCommandTests.cs (1)

439public string AppDirectoryPath => Environment.CurrentDirectory;

Commands\SdkDumpCommandTests.cs (13)

311Environment.CurrentDirectory = repoRoot; 312Environment.SetEnvironmentVariable("ASPIRE_REPO_ROOT", repoRoot); 313Environment.SetEnvironmentVariable(CliConfigNames.NoLogo, "true"); 314Environment.SetEnvironmentVariable("DOTNET_CLI_TELEMETRY_OPTOUT", "true"); 315Environment.SetEnvironmentVariable("DOTNET_SKIP_FIRST_TIME_EXPERIENCE", "true"); 316Environment.SetEnvironmentVariable("DOTNET_GENERATE_ASPNET_CERTIFICATE", "false"); 336Console.WriteLine($"SDK dump stdout:{Environment.NewLine}{standardOutput}"); 337Console.WriteLine($"SDK dump stderr:{Environment.NewLine}{standardError}"); 341$"aspire sdk dump --format ci failed for '{projectPath}'. Expected exit code {CliExitCodes.Success}, actual {exitCode}.{Environment.NewLine}" + 342$"stdout:{Environment.NewLine}{standardOutput}{Environment.NewLine}stderr:{Environment.NewLine}{standardError}"); 348.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries)

Commands\StopCommandTests.cs (1)

1307$"{appHostId}a1b2c{instanceSuffix}.{Environment.ProcessId.ToString(CultureInfo.InvariantCulture)}");

DotNet\DotNetCliRunnerTests.cs (3)

32var dotnetRoot = Environment.GetEnvironmentVariable("DOTNET_ROOT"); 323if (Environment.ProcessPath is { } processPath && DotNetCliRunner.ShouldForwardProcessPathAsAspireCliPath(processPath)) 2740public int ProcessId => Environment.ProcessId;

DotNet\ProcessExecutionDetachedTests.cs (2)

39Environment.CurrentDirectory); 108$"monitorPid={Environment.ProcessId.ToString(CultureInfo.InvariantCulture)}",

DotNet\ProcessExecutionTests.cs (16)

DotNetSdkInstallerTests.cs (9)

Git\GitWorktreeTests.cs (7)

164Path.GetRelativePath(adminDirectory, gitFilePath) + Environment.NewLine); 187$"gitdir: {adminDirectory}{Path.DirectorySeparatorChar}{Environment.NewLine}"); 205gitFilePath + Environment.NewLine); 226caseVariantGitFile + Environment.NewLine); 264Path.Combine(aliasRoot, ".git") + Environment.NewLine); 304gitFilePath + Environment.NewLine); 323otherGitFile + Environment.NewLine);

HeldFileLeaseTests.cs (1)

170if (OperatingSystem.IsWindows() || Environment.IsPrivilegedProcess)

Interaction\SpectreConsoleLoggerProviderTests.cs (5)

188var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 213var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 234var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 250var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 282var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);

Layout\LayoutDiscoveryReparsePointTests.cs (9)

Layout\LayoutProcessRunnerTests.cs (2)

27Assert.Equal(Environment.ProcessId.ToString(CultureInfo.InvariantCulture), capturedEnv["ASPIRE_CLI_PID"]); 69Assert.Equal(Environment.ProcessId.ToString(CultureInfo.InvariantCulture), capturedEnv["ASPIRE_CLI_PID"]);

Mcp\SelectAppHostToolTests.cs (1)

46ProcessId = Environment.ProcessId

Npm\NpmRunnerTests.cs (1)

160var existingPath = Environment.GetEnvironmentVariable("PATH") ?? string.Empty;

NuGet\NuGetPackagePrefetcherTests.cs (2)

26var workingDir = new DirectoryInfo(Environment.CurrentDirectory); 527var workingDir = new DirectoryInfo(Environment.CurrentDirectory);

Processes\IsolatedProcessTests.cs (5)

22WorkingDirectory = Environment.CurrentDirectory, 53WorkingDirectory = Environment.CurrentDirectory, 85WorkingDirectory = Environment.CurrentDirectory, 128WorkingDirectory = Environment.CurrentDirectory, 169WorkingDirectory = Environment.CurrentDirectory,

Processes\LauncherLivenessMonitorTests.cs (1)

56["ASPIRE_LAUNCHER_PID"] = Environment.ProcessId.ToString(CultureInfo.InvariantCulture),

Processes\OrphanDetectionEnvironmentTests.cs (4)

19Assert.Equal(Environment.ProcessId.ToString(CultureInfo.InvariantCulture), environment[KnownConfigNames.CliProcessId]); 31Assert.Equal(Environment.ProcessId.ToString(CultureInfo.InvariantCulture), environment[KnownConfigNames.CliLauncherProcessId]); 64Assert.Equal(Environment.ProcessId.ToString(CultureInfo.InvariantCulture), environment[KnownConfigNames.CliProcessId]); 79Assert.Equal(Environment.ProcessId.ToString(CultureInfo.InvariantCulture), environment[KnownConfigNames.CliProcessId]);

Processes\ParentProcessLivenessMonitorTests.cs (1)

73Environment.ProcessId,

Processes\ProcessTreeGracefulShutdownServiceTests.cs (4)

40var result = await signaler.TryStopProcessTreeWithDcpAsync(Environment.ProcessId, startTime, includeStartTime: true, CancellationToken.None); 51Environment.ProcessId.ToString(CultureInfo.InvariantCulture), 72Environment.ProcessId, 101var result = await signaler.TryStopProcessTreeWithDcpAsync(Environment.ProcessId, ProcessStartTimeHelper.GetCurrentProcessStartTime(), includeStartTime: false, CancellationToken.None);

Processes\WindowsConsoleProcessJobTests.cs (2)

98Environment.CurrentDirectory, 147Environment.CurrentDirectory,

ProfileCaptureOptionsTests.cs (10)

ProgramTests.cs (1)

77Environment.SetEnvironmentVariable(BundleDiscovery.BundleVersionDirectoryEnvVar, versionDirectory);

Projects\AppHostServerProjectTests.cs (1)

135Assert.True(process.ExitCode == 0, $"{output}{Environment.NewLine}{error}");

Projects\DotNetAppHostProjectTests.cs (4)

422var socketPath = CreateMatchingSocketFile(appHostFile.FullName, Environment.ProcessId); 1710var previousValue = Environment.GetEnvironmentVariable(variableName); 1711Environment.SetEnvironmentVariable(variableName, "expanded-value"); 1761Environment.SetEnvironmentVariable(variableName, previousValue);

Projects\GuestRuntimeTests.cs (1)

1542Assert.SkipWhen(Environment.GetEnvironmentVariable("USER") == "root", "root bypasses directory permissions, so the traversal never fails.");

Projects\JavaAppHostToolchainResolverTests.cs (5)

30Assert.Equal(Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe", actual.Command); 326Assert.Equal(Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe", invocation.Command); 673return (-1, $"Maven timed out after 10 minutes.{Environment.NewLine}{await standardOutput}{Environment.NewLine}{await standardError}"); 676return (process.ExitCode, $"{await standardOutput}{Environment.NewLine}{await standardError}");

Projects\ProcessGuestLauncherTests.cs (11)

Projects\ProjectLocatorTests.cs (2)

2611var directory = new DirectoryInfo(Path.Combine(Path.GetPathRoot(Environment.CurrentDirectory)!, "repo", "Apps")); 2612var file = new FileInfo(Path.Combine(Path.GetPathRoot(Environment.CurrentDirectory)!, "repo", "apps", "AppHost.csproj"));

Projects\ProjectUpdaterTests.cs (2)

1637Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NuGet", "NuGet.Config")

Scaffolding\ScaffoldingServiceTests.cs (1)

113Assert.False(serialized.EndsWith(Environment.NewLine, StringComparison.Ordinal));

Telemetry\AspireCliTelemetryTests.cs (1)

242Assert.Contains(tags, t => t.Key == TelemetryConstants.Tags.OsVersion && t.Value is string s && s == Environment.OSVersion.Version.ToString());

Telemetry\InternalMicrosoftDetectorTests.cs (3)

970Environment.GetEnvironmentVariable("ASPIRE_TEST_LIVE_MAC_PLATFORM_SSO") == "1", 1008var result = InternalMicrosoftDetector.EvaluateMacPlatformSso($"{stdout}{Environment.NewLine}{stderr}"); 1848public int ProcessId => Environment.ProcessId;

tests\Shared\Logging\XunitLoggerProvider.cs (3)

45private static readonly string[] s_newLineChars = new[] { Environment.NewLine }; 96if (message.EndsWith(Environment.NewLine, StringComparison.Ordinal)) 98message = message.Substring(0, message.Length - Environment.NewLine.Length);

TestServices\EnvVarOverride.cs (3)

19_previous = Environment.GetEnvironmentVariable(name); 20Environment.SetEnvironmentVariable(name, value); 25Environment.SetEnvironmentVariable(_name, _previous);

TestServices\TestDotNetCliRunner.cs (5)

89return Environment.OSVersion.Platform switch 91PlatformID.Win32NT => [Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NuGet", "NuGet.Config")], 92_ => [Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".nuget", "NuGet.Config")],

TestServices\TestGitWorktree.cs (2)

21File.WriteAllText(Path.Combine(adminDirectory, "gitdir"), backPointer + Environment.NewLine); 37File.WriteAllText(gitFilePath, $"gitdir: {pointer}{Environment.NewLine}");

TestServices\TestProcessExecutionFactory.cs (1)

188public int ProcessId { get; init; } = Environment.ProcessId;

TestTelemetryDefaults.cs (1)

31Environment.SetEnvironmentVariable(AspireCliTelemetry.TelemetryOptOutConfigKey, "true");

Utils\AspireRepositoryDetectorTests.cs (5)

16private readonly string? _originalRepoRoot = Environment.GetEnvironmentVariable(RepoRootEnvironmentVariableName); 25Environment.SetEnvironmentVariable(RepoRootEnvironmentVariableName, _originalRepoRoot); 56Environment.SetEnvironmentVariable(RepoRootEnvironmentVariableName, repoRoot); 70Environment.SetEnvironmentVariable(RepoRootEnvironmentVariableName, envRoot); 83Environment.SetEnvironmentVariable(RepoRootEnvironmentVariableName, cachedRoot);

Utils\CliPathHelperTests.cs (4)

32var expectedDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".aspire", "cli", "bch"); 50var expectedDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".aspire", "cli", "bch");

Utils\ConsoleActivityLoggerTests.cs (5)

313var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 342var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 366var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 388var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 424var lines = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);

Aspire.Dashboard (18)

Components\Pages\Traces.razor.cs (3)

116tooltip += Environment.NewLine + string.Format(CultureInfo.InvariantCulture, Loc[nameof(Dashboard.Resources.Traces.TracesTraceId)], trace.TraceId); 127tooltip += Environment.NewLine + string.Format(CultureInfo.InvariantCulture, Loc[nameof(Dashboard.Resources.Traces.TracesTotalTraces)], count); 130tooltip += Environment.NewLine + string.Format(CultureInfo.InvariantCulture, Loc[nameof(Dashboard.Resources.Traces.TracesTotalErroredTraces)], errorCount);

DashboardWebApplication.cs (4)

1086Debug.Assert(_validationFailures.Count == 0, "Validation failures: " + Environment.NewLine + string.Join(Environment.NewLine, _validationFailures)); 1092Debug.Assert(_validationFailures.Count == 0, "Validation failures: " + Environment.NewLine + string.Join(Environment.NewLine, _validationFailures));

Model\GenAI\GenAIVisualizerDialogViewModel.cs (2)

171Environment.NewLine + Environment.NewLine,

Model\Markdown\MarkdownProcessor.cs (1)

27pipelineBuilder.ConfigureNewLine(Environment.NewLine);

Model\Otlp\ResourcesSelectHelpers.cs (3)

59""", name, fallback, string.Join(Environment.NewLine, resources), match); 74""", name, string.Join(Environment.NewLine, resources), string.Join(Environment.NewLine, matches));

Model\Otlp\SpanWaterfallViewModel.cs (2)

42tooltip += Environment.NewLine + "Status = Error"; 46tooltip += Environment.NewLine + $"Outgoing call to {UninstrumentedPeer}";

src\Shared\AspireHomeDirectory.cs (3)

22Environment.GetEnvironmentVariable(EnvironmentVariable), 23Environment.GetFolderPath(Environment.SpecialFolder.UserProfile));

Aspire.Dashboard.Components.Tests (3)

tests\Shared\Logging\XunitLoggerProvider.cs (3)

Aspire.Dashboard.Tests (11)

Integration\Playwright\AccessibilityTests.cs (4)

214$"Dark accent button state contrast falls below the WCAG AA {WcagAaContrastMinimum:F1}:1 minimum:{Environment.NewLine}{string.Join(Environment.NewLine, failures)}"); 312$"in the {theme} theme:{Environment.NewLine}{string.Join(Environment.NewLine, failures)}");

Model\DashboardSqliteDatabaseTests.cs (1)

106var query = $"-- {Guid.NewGuid():N}{Environment.NewLine}SELECT 42;";

tests\Shared\Logging\XunitLoggerProvider.cs (3)

tests\Shared\Playwright\PlaywrightProvider.cs (3)

19string? browserPath = Environment.GetEnvironmentVariable(BrowserPathEnvironmentVariableName); 42if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable(PlaywrightBrowsersPathEnvironmentVariableName))) 58Environment.SetEnvironmentVariable(PlaywrightBrowsersPathEnvironmentVariableName, probePath);

Aspire.Deployment.EndToEnd.Tests (44)

AzureConnectorNamespaceDeploymentTests.cs (2)

36Environment.GetEnvironmentVariable(EnableEnvironmentVariable), 157var value = Environment.GetEnvironmentVariable(environmentVariable);

AzureSandboxesDeploymentTests.cs (2)

438Environment.NewLine, 645!string.Equals(Environment.GetEnvironmentVariable(EnableSandboxesEnvironmentVariable), "true", StringComparison.OrdinalIgnoreCase))

Helpers\AzureAuthenticationHelpers.cs (6)

61var subscriptionId = Environment.GetEnvironmentVariable(SubscriptionEnvVar); 66subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID"); 98var prefix = Environment.GetEnvironmentVariable(ResourceGroupPrefixEnvVar); 114var runId = Environment.GetEnvironmentVariable("GITHUB_RUN_ID"); 176return Environment.GetEnvironmentVariable("AZURE_TENANT_ID"); 184return Environment.GetEnvironmentVariable("AZURE_CLIENT_ID");

Helpers\DeploymentE2ETestHelpers.cs (10)

tests\Shared\CliInstallStrategy.cs (21)

tests\Shared\Hex1bAutomatorTestHelpers.cs (2)

tests\Shared\Hex1bTestHelpers.cs (1)

120var githubWorkspace = Environment.GetEnvironmentVariable("GITHUB_WORKSPACE");

Aspire.EndToEnd.Tests (28)

tests\Shared\Playwright\PlaywrightProvider.cs (3)

tests\Shared\TemplatesTesting\AspireProject.cs (3)

312var exceptionMessage = $"{reason}: {Environment.NewLine}{outputMessage}"; 354if (Environment.GetEnvironmentVariable("DASHBOARD_URL_FOR_TEST") is string dashboardUrlForTest) 535msg += $" Content:{Environment.NewLine}{contentStr}";

tests\Shared\TemplatesTesting\BuildEnvironment.cs (9)

tests\Shared\TemplatesTesting\CommandResult.cs (2)

32_ = message.AppendLine(CultureInfo.InvariantCulture, $"{Environment.NewLine}Standard Output:{Environment.NewLine}{Output}");

tests\Shared\TemplatesTesting\EnvironmentVariables.cs (10)

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

203return string.Join(System.Environment.NewLine, outputLines);

Aspire.Hosting (70)

ApplicationModel\ResourceCommandService.cs (2)

203errorMessage += Environment.NewLine + string.Join(Environment.NewLine, failures.Select(f => $"Resource '{f.resourceId}' failed with error message: {f.result.Message}"));

Backchannel\AuxiliaryBackchannelRpcTarget.cs (2)

903ProcessId = Environment.ProcessId, 910StableStartedAt = ProcessStartTimeHelper.TryGetProcessStartTime(Environment.ProcessId),

Backchannel\AuxiliaryBackchannelService.cs (3)

47Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 48Environment.ProcessId,

Dashboard\DashboardEventHandlers.cs (1)

1022(s, _) => (logMessage.Exception is { } e) ? s + Environment.NewLine + e : s);

Dcp\DcpDependencyCheck.cs (2)

91$"'dcp {arguments}' returned exit code {processResult.ExitCode}. {errorStringBuilder.ToString()}{Environment.NewLine}{outputStringBuilder.ToString()}" 119$"{ex.Message} {errorStringBuilder.ToString()}{Environment.NewLine}{outputStringBuilder.ToString()}"

Dcp\DcpHost.cs (2)

303var arguments = $"start-apiserver --monitor {Environment.ProcessId} --detach --kubeconfig \"{locations.DcpKubeconfigPath}\""; 339foreach (DictionaryEntry de in Environment.GetEnvironmentVariables())

Dcp\DcpProcessMonitor.cs (1)

54var procRoot = Environment.GetEnvironmentVariable("HOST_PROC") ?? "/proc";

Dcp\ExecutableConfigurationResolver.cs (1)

51var existingSslCertDirectory = Environment.GetEnvironmentVariable(

Dcp\Process\ProcessOutputCapture.cs (2)

80var formattedOutput = string.Join(Environment.NewLine, lines); 84return $"{outputDescription} truncated: showing last {linesShown} of {totalLineCount} lines.{Environment.NewLine}{formattedOutput}";

Dcp\Process\ProcessUtil.cs (1)

160message = $"{message}{Environment.NewLine}{outputCapture.GetFormattedOutput()}";

Devcontainers\DevcontainerSettingsWriter.cs (2)

39Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

DeveloperCertificateService.cs (2)

149Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".aspire", "dev-certs", "https");

Diagnostics\ProfilingTelemetry.cs (2)

721return IsTruthy(Environment.GetEnvironmentVariable(KnownConfigNames.ProfilingEnabled)) || 722IsTruthy(Environment.GetEnvironmentVariable(KnownConfigNames.Legacy.StartupProfilingEnabled));

DistributedApplication.cs (5)

287if (Environment.GetEnvironmentVariable(KnownConfigNames.WaitForDebugger) == "true") 292if (Environment.GetEnvironmentVariable(KnownConfigNames.WaitForDebuggerTimeout) is string timeoutString && int.TryParse(timeoutString, out var timeoutSeconds)) 297Console.WriteLine($"AppHost PID: {Environment.ProcessId}"); 301Console.WriteLine($"Waiting for debugger to attach to process: {Environment.ProcessId}"); 305Console.WriteLine($"Timeout waiting for debugger to attach to process: {Environment.ProcessId}");

Lifecycle\TerminalHostOrphanCleanupService.cs (6)

67var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 211?? $"name:{Environment.MachineName}"; 213?? $"unresolved:{Environment.ProcessId}"; 214return $"linux:{machineScope}:{Environment.MachineName}:pidns:{pidNamespace}"; 217return $"machine:{Environment.MachineName}";

Orchestrator\ApplicationOrchestrator.cs (1)

359Url = $"{allocatedEndpoint.UriScheme}://{Environment.MachineName}:{allocatedEndpoint.Port}",

Pipelines\Internal\FileDeploymentStateManager.cs (2)

216Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),

Pipelines\PipelineOutputService.cs (3)

43: Path.Combine(Environment.CurrentDirectory, "aspire-output"); 51var baseDirectory = Environment.CurrentDirectory; 61baseDirectory = Environment.CurrentDirectory;

ProjectResourceBuilderExtensions.cs (3)

803var value = Environment.ExpandEnvironmentVariables(envVar.Value); 1043var env = Environment.GetEnvironmentVariable(KnownAspNetCoreConfigNames.Environment) ?? Environment.GetEnvironmentVariable(KnownAspNetCoreConfigNames.DotNetEnvironment);

Publishing\ContainerRuntimeBase.cs (6)

366message = $"{message}{Environment.NewLine}{processResult.GetFormattedOutput()}"; 412message = $"{message}{Environment.NewLine}{processResult.GetFormattedOutput(outputDescription: "Command output")}"; 601throw new DistributedApplicationException($"{Name} {operationName} for '{imageName}' failed with exit code {processResult.ExitCode}.{Environment.NewLine}{processResult.GetFormattedOutput()}"); 605return string.Join(Environment.NewLine, stdout); 681var envHint = Environment.GetEnvironmentVariable("ASPIRE_CONTAINER_RUNTIME") is not null 692message = $"{message}{Environment.NewLine}{processResult.GetFormattedOutput()}";

Publishing\ProcessFailedException.cs (1)

45? $"{base.Message}{Environment.NewLine}{GetFormattedOutput()}"

src\Shared\BundleDiscovery.cs (1)

375var processPath = Environment.ProcessPath;

src\Shared\PathLookupHelper.cs (6)

src\Shared\ProcessStartTimeHelper.cs (1)

62if (TryGetProcessStartTime(Environment.ProcessId) is { } startTime)

src\Shared\UserSecrets\UserSecretsPathHelper.cs (7)

TerminalResourceBuilderExtensions.cs (4)

185var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 206var appHostPid = Environment.ProcessId; 231var hostLogLevel = Environment.GetEnvironmentVariable("ASPIRE_TERMINAL_HOST_LOG_LEVEL");

Utils\DotnetSdkUtils.cs (1)

28WorkingDirectory = workingDirectory ?? Environment.CurrentDirectory,

Aspire.Hosting.Azure (11)

Provisioning\Internal\BicepCompiler.cs (2)

77: $"Failed to compile bicep file: {bicepFilePath}{Environment.NewLine}{errorMessage}", 88: $"Failed to compile bicep file: {bicepFilePath}{Environment.NewLine}{errorMessage}");

src\Aspire.Hosting\Dcp\Process\ProcessOutputCapture.cs (2)

src\Aspire.Hosting\Dcp\Process\ProcessUtil.cs (1)

160message = $"{message}{Environment.NewLine}{outputCapture.GetFormattedOutput()}";

src\Shared\PathLookupHelper.cs (6)

Aspire.Hosting.Azure.CosmosDB (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Hosting.Azure.Kubernetes (1)

AzureKubernetesEnvironmentResource.AksPipeline.cs (1)

638$"kubectl apply for ApplicationLoadBalancer '{lb.AlbName}' failed (exit code {applyExitCode}).{Environment.NewLine}{detail}");

Aspire.Hosting.Azure.Kusto (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Hosting.Azure.Storage (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Hosting.Azure.Tests (16)

AzureBicepResourceTests.cs (1)

189bicepResource.Resource.TempDirectory = Environment.CurrentDirectory;

AzureContainerAppsTests.cs (2)

186builder.AddExecutable("api", "node.exe", Environment.CurrentDirectory) 226builder.AddExecutable("api", "node.exe", Environment.CurrentDirectory)

AzureDeployerTests.cs (5)

708Environment.NewLine, 725var end = diagnostics.IndexOf($"{Environment.NewLine}{Environment.NewLine}If targeting '", start + marker.Length, StringComparison.Ordinal); 1685Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),

FoundryExtensionsTests.cs (7)

309var originalPath = Environment.GetEnvironmentVariable("PATH"); 339Environment.SetEnvironmentVariable("PATH", $"{temporaryDirectory.FullName}{Path.PathSeparator}{originalPath}"); 340Environment.SetEnvironmentVariable("FOUNDRY_FAKE_LOG", commandLogPath); 341Environment.SetEnvironmentVariable("FOUNDRY_FAKE_CACHED", cached.ToString().ToLowerInvariant()); 377Environment.SetEnvironmentVariable("PATH", originalPath); 378Environment.SetEnvironmentVariable("FOUNDRY_FAKE_LOG", null); 379Environment.SetEnvironmentVariable("FOUNDRY_FAKE_CACHED", null);

PublicApiTests\AppContainersPublicApiTests.cs (1)

64var executable = builder.AddExecutable("api", "node.exe", Environment.CurrentDirectory);

Aspire.Hosting.Blazor (3)

BlazorDotNetCliRunner.cs (1)

22var executablePath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") is { Length: > 0 } dotnetHostPath

BlazorGatewayExtensions.cs (2)

783var runtimeMajor = Environment.Version.Major; 784var runtimeMinor = Environment.Version.Minor;

Aspire.Hosting.Blazor.Tests (2)

BlazorHostedExtensionsTests.cs (2)

578$"Failed to restore '{projectPath}'.{Environment.NewLine}{result.StandardOutput}{Environment.NewLine}{result.StandardError}");

Aspire.Hosting.Browsers (25)

BrowserLogsArtifacts.cs (7)

115Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), 123Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 130var xdgDataHome = Environment.GetEnvironmentVariable("XDG_DATA_HOME"); 133: Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "share");

BrowserLogsPipeBrowserProcessLauncher.Unix.cs (1)

312var environmentVariables = Environment.GetEnvironmentVariables();

BrowserUserDataPathResolver.cs (7)

77Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), 85Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 94var xdgDataHome = Environment.GetEnvironmentVariable("XDG_DATA_HOME"); 97: Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "share");

ChromiumBrowserResolver.cs (4)

234var programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); 235var programFilesX86 = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);

src\Shared\PathLookupHelper.cs (6)

Aspire.Hosting.Browsers.Tests (29)

BrowserHostTests.cs (1)

33Environment.ProcessId,

BrowserLogsSessionManagerTests.cs (3)

182Environment.ProcessId, 329"processId": {{Environment.ProcessId}}, 361Environment.ProcessId,

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

src\Aspire.Hosting.Browsers\BrowserLogsPipeBrowserProcessLauncher.Unix.cs (1)

312var environmentVariables = Environment.GetEnvironmentVariables();

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

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

234var programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); 235var programFilesX86 = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);

src\Shared\PathLookupHelper.cs (6)

Aspire.Hosting.CodeGeneration.Java.Tests (140)

AtsJavaCodeGeneratorTests.cs (140)

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

AtsPythonCodeGeneratorTests.cs (1)

430$"Python callback validation failed.{Environment.NewLine}{await standardOutput}{await standardError}");

Aspire.Hosting.Containers.Tests (3)

ResourceFailureLoggingTests.cs (3)

135$"Expected exactly one log line for {expected}, but found {matches.Count}.{Environment.NewLine}Captured resource logs:{Environment.NewLine}{FormatLogLines(logLines)}"); 142: string.Join(Environment.NewLine, logLines.Select((line, index) => $"{index + 1}: {line}"));

Aspire.Hosting.DevTunnels (1)

DevTunnelResourceBuilderExtensions.cs (1)

848$" {Environment.NewLine}",

Aspire.Hosting.DevTunnels.Tests (6)

DevTunnelResourceBuilderExtensionsTests.cs (6)

584$"**Tunnel URL:** <https://n4skq32k-3000.use.devtunnels.ms> {Environment.NewLine}" + 585$"**Inspect URL:** <https://n4skq32k-3000-inspect.use.devtunnels.ms> {Environment.NewLine}" + 632$"**Tunnel URL:** <https://n4skq32k-3000.use.devtunnels.ms> {Environment.NewLine}" + 679$"**Tunnel URL:** <https://n4skq32k-3000.use.devtunnels.ms> {Environment.NewLine}" + 680$"**Inspect URL:** <https://n4skq32k-3000-inspect.use.devtunnels.ms> {Environment.NewLine}" + 711var target = builder.AddExecutable("target", command, Environment.CurrentDirectory, arguments)

Aspire.Hosting.Docker (9)

src\Aspire.Hosting\Dcp\Process\ProcessOutputCapture.cs (2)

src\Aspire.Hosting\Dcp\Process\ProcessUtil.cs (1)

160message = $"{message}{Environment.NewLine}{outputCapture.GetFormattedOutput()}";

src\Shared\PathLookupHelper.cs (6)

Aspire.Hosting.Dotnet (1)

DotnetProjectBuildArtifactManager.cs (1)

74string.Create(CultureInfo.InvariantCulture, $"{Environment.ProcessId}-"),

Aspire.Hosting.Dotnet.Tests (3)

DotnetProjectBuildEnvironmentTests.cs (2)

30$"\"--property:BUILD_FLAVOR=custom\u2003%22flavor%22%3B%0D%0Avalue%25\"{Environment.NewLine}" + 31$"\"--property:BUILD%0AINJECTED=safe\"{Environment.NewLine}",

DotnetProjectResourceTests.cs (1)

906app.WithParentProcessLifetime(Environment.ProcessId);

Aspire.Hosting.Foundry (4)

FoundryLocalService.cs (1)

488return string.Join(Environment.NewLine, output);

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Hosting.GitHub.Models (1)

GitHubModelsExtensions.cs (1)

39Environment.GetEnvironmentVariable("GITHUB_TOKEN") ??

Aspire.Hosting.Java (2)

JavaHostingExtensions.cs (2)

1510return (Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe", ["/c", "call", relativeWrapperPath]); 1515? Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe"

Aspire.Hosting.Java.Tests (2)

AddJavaAppTests.cs (1)

414Assert.Equal(Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe", command);

ExpectedWrapperInvocation.cs (1)

24? Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe"

Aspire.Hosting.JavaScript.Tests (6)

AddDenoAppTests.cs (5)

406Assert.True(copySourceIndex >= 0, string.Join(Environment.NewLine, dockerfileLines)); 407Assert.True(installIndex > copySourceIndex, string.Join(Environment.NewLine, dockerfileLines)); 431Assert.True(copySourceIndex >= 0, string.Join(Environment.NewLine, dockerfileLines)); 432Assert.True(installIndex > copySourceIndex, string.Join(Environment.NewLine, dockerfileLines)); 712Assert.DoesNotContain(dockerfileContents.Split(Environment.NewLine), line => line.StartsWith("USER ", StringComparison.Ordinal));

AddViteAppTests.cs (1)

387var toolVersions = string.Join(Environment.NewLine,

Aspire.Hosting.Kubernetes (9)

src\Aspire.Hosting\Dcp\Process\ProcessOutputCapture.cs (2)

src\Aspire.Hosting\Dcp\Process\ProcessUtil.cs (1)

160message = $"{message}{Environment.NewLine}{outputCapture.GetFormattedOutput()}";

src\Shared\PathLookupHelper.cs (6)

Aspire.Hosting.Maui.Tests (1)

MauiPlatformExtensionsTests.cs (1)

1209Environment.CurrentDirectory);

Aspire.Hosting.OpenAI (1)

OpenAIExtensions.cs (1)

34Environment.GetEnvironmentVariable("OPENAI_API_KEY") ??

Aspire.Hosting.Python (1)

PythonAppResourceBuilderExtensions.cs (1)

1256var pathVariable = Environment.GetEnvironmentVariable("PATH");

Aspire.Hosting.Radius (3)

Publishing\SealedSecretApplyStep.cs (3)

75Environment.GetEnvironmentVariable(KubeContextOverrideEnvironmentVariable), 672var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Aspire.Hosting.RemoteHost (1)

src\Shared\ProcessStartTimeHelper.cs (1)

62if (TryGetProcessStartTime(Environment.ProcessId) is { } startTime)

Aspire.Hosting.RemoteHost.Tests (14)

CapabilityDispatcherTests.cs (14)

Aspire.Hosting.Sdk.Tests (5)

AppHostSdkTargetsTests.cs (5)

832Assert.True(File.Exists(childPidPath), $"The child process did not record its PID. MSBuild output:{Environment.NewLine}{result.Output}"); 1635Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), 1777? $"{directory}{Path.PathSeparator}{Environment.GetEnvironmentVariable(pathEnvironmentVariable)}" 1795var currentPath = Environment.GetEnvironmentVariable(pathEnvironmentVariable) ?? string.Empty;

Aspire.Hosting.Tasks (5)

CommandPathResolver.cs (1)

15path ??= Environment.GetEnvironmentVariable("PATH");

ResolveAspireCliBundle.cs (3)

460var aspireHome = Environment.GetEnvironmentVariable(AspireHomeEnvironmentVariable); 462? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".aspire")

RunAspireCliCommand.cs (1)

339return Environment.GetEnvironmentVariable("ComSpec") ?? "cmd.exe";

Aspire.Hosting.Testing (1)

DistributedApplicationFactory.cs (1)

428if (uint.TryParse(Environment.GetEnvironmentVariable(TimeoutEnvironmentKey), out var timeoutInSeconds))

Aspire.Hosting.Testing.Tests (7)

DashboardUrlTests.cs (1)

345Environment.NewLine,

tests\Shared\Logging\XunitLoggerProvider.cs (3)

tests\Shared\Playwright\PlaywrightProvider.cs (3)

Aspire.Hosting.Tests (119)

AppHostSmokeTests.cs (1)

44Environment.SetEnvironmentVariable(envVar, loc);

Backchannel\AuxiliaryBackchannelRpcTargetTests.cs (1)

2851Assert.Equal(ProcessStartTimeHelper.TryGetProcessStartTimeUnixMilliseconds(Environment.ProcessId), result.StableStartedAt.Value.ToUnixTimeMilliseconds());

Backchannel\AuxiliaryBackchannelTests.cs (5)

639Environment.ProcessId, 672Environment.ProcessId, 703Environment.ProcessId, 733var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Cli\ProcessStartTimeHelperTests.cs (7)

13Assert.True(ProcessStartTimeHelper.IsProcessRunning(Environment.ProcessId)); 20Assert.True(ProcessStartTimeHelper.IsProcessRunning(Environment.ProcessId, startedUnix)); 27Assert.False(ProcessStartTimeHelper.IsProcessRunning(Environment.ProcessId, expectedStartTimeUnixMilliseconds: 1)); 60var fromPid = ProcessStartTimeHelper.TryGetProcessStartTimeUnixMilliseconds(Environment.ProcessId); 70Assert.True(ProcessStartTimeHelper.IsProcessRunningWithRuntimeStartTime(Environment.ProcessId, startedUnix)); 97var startTicks = ProcessStartTimeHelper.TryGetLinuxProcessStartTicks(Environment.ProcessId, ProcessStartTimeHelper.LinuxProcRoot); 198Assert.False(ProcessStartTimeHelper.IsProcessRunning(Environment.ProcessId, startedMs + 500));

Dashboard\DashboardEventHandlersTests.cs (1)

934$"Error message{Environment.NewLine}System.InvalidOperationException: Error!",

Dcp\DcpExecutorTests.cs (64)

Dcp\ProcessUtilTests.cs (1)

193var outputLines = exception.Message.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);

DistributedApplicationBuilderTests.cs (13)

235Assert.Equal(Path.Combine(Environment.CurrentDirectory, "aspire-output"), outputService.GetOutputDirectory()); 583Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 605Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 679Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 738Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 802Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 863Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),

DistributedApplicationTests.cs (1)

2043var executable = builder.AddExecutable($"{testName}-executable", "dotnet", Environment.CurrentDirectory, "--info")

MSBuildTests.cs (6)

233Assert.True(result.ExitCode == 0, $"Build failed: {Environment.NewLine}{result.Output}"); 262Assert.True(result.ExitCode == 0, $"Pack failed: {Environment.NewLine}{result.Output}"); 347Assert.True(result.ExitCode == 0, $"MSBuild query failed: {Environment.NewLine}{result.Output}"); 521Assert.True(result.ExitCode == 0, $"Design-time build failed: {Environment.NewLine}{result.Output}"); 786File.Copy(Path.Combine(Environment.SystemDirectory, "where.exe"), dnxPath); 1119var currentPath = Environment.GetEnvironmentVariable("PATH") ?? string.Empty;

ProjectResourceTests.cs (1)

605: $",{Environment.NewLine} \"ASPNETCORE_FORWARDEDHEADERS_ENABLED\": \"true\"";

Publishing\DeploymentStateManagerTests.cs (2)

458Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),

Publishing\ResourceContainerImageManagerTests.cs (2)

1554var newlineIndex = ex.Message.IndexOf(Environment.NewLine, StringComparison.Ordinal); 1557Assert.Equal(ex.GetFormattedOutput(), ex.Message[(newlineIndex + Environment.NewLine.Length)..]);

ResourceBuilderLifetimeTests.cs (4)

46.WithParentProcessLifetime(Environment.ProcessId) 63container.WithParentProcessLifetime(Environment.ProcessId); 67Assert.Equal(Environment.ProcessId, annotation.ParentProcessId); 163.WithParentProcessLifetime(Environment.ProcessId)

ResourceFailureLoggingTests.cs (3)

93$"Expected exactly one log line for {expected}, but found {matches.Count}.{Environment.NewLine}Captured resource logs:{Environment.NewLine}{FormatLogLines(logLines)}"); 100: string.Join(Environment.NewLine, logLines.Select((line, index) => $"{index + 1}: {line}"));

Schema\SchemaTests.cs (1)

840Assert.True(results.IsValid, string.Join(Environment.NewLine, errorMessages ?? ["Schema failed validation with no errors"]));

WithEndpointTests.cs (1)

850url => Assert.StartsWith($"https://{Environment.MachineName}:", url.Url));

WithProcessCommandTests.cs (1)

839result.Data.Value.Split(Environment.NewLine, StringSplitOptions.None));

WithTerminalTests.cs (4)

437Assert.Equal(Environment.ProcessId, root.GetProperty("appHostPid").GetInt32()); 598appHostPid: Environment.ProcessId, 912appHostPid: Environment.ProcessId, 1237Environment.ProcessId.ToString(System.Globalization.CultureInfo.InvariantCulture),

Aspire.Hosting.TestUtilities (12)

tests\Shared\Logging\XunitLoggerProvider.cs (3)

Utils\DockerUtils.cs (2)

82var configuredRuntime = Environment.GetEnvironmentVariable(KnownConfigNames.ContainerRuntime) 83?? Environment.GetEnvironmentVariable(KnownConfigNames.Legacy.ContainerRuntime);

Utils\DotnetFileAppProcess.cs (1)

12public static string ExecutablePath { get; } = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") ?? "dotnet";

Utils\ManifestUtils.cs (3)

22manifestDirectory ??= Environment.CurrentDirectory; 47manifestDirectory ??= Environment.CurrentDirectory; 75var context = new ManifestPublishingContext(executionContext, Path.Combine(Environment.CurrentDirectory, "manifest.json"), writer);

Utils\PersistentContainerTestHelpers.cs (1)

143? string.Join(Environment.NewLine, resourceEvent.Snapshot.Urls

Utils\UnixSocketHelper.cs (2)

12var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Aspire.Managed.Tests (7)

TerminalHostSignalTests.cs (7)

53$"aspire-managed exited before binding its sockets with code {process.ExitCode}.{Environment.NewLine}" + 66$"aspire-managed exited with code {process.ExitCode}.{Environment.NewLine}" + 67$"stdout: {standardOutput}{Environment.NewLine}stderr: {standardError}"); 120$"The parent terminal host exited before binding its sockets with code {parentProcess.ExitCode}.{Environment.NewLine}" + 150$"The terminal host exited before binding its sockets with code {process.ExitCode}.{Environment.NewLine}" + 164$"aspire-managed exited with code {process.ExitCode}.{Environment.NewLine}" + 165$"stdout: {standardOutput}{Environment.NewLine}stderr: {standardError}");

Aspire.Microsoft.Azure.Cosmos (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Microsoft.Azure.StackExchangeRedis (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Microsoft.EntityFrameworkCore.Cosmos (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.Microsoft.Extensions.Configuration.AzureAppConfiguration (3)

src\Shared\AzureCredentialHelper.cs (3)

Aspire.OpenAI (1)

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

16Environment.GetEnvironmentVariable(KnownOtelConfigNames.InstrumentationGenAiCaptureMessageContent) is string envVar &&

Aspire.Playground.Tests (22)

AppHostTests.cs (1)

23private static readonly string? s_appHostNameFilter = Environment.GetEnvironmentVariable("TEST_PLAYGROUND_APPHOST_FILTER");

src\Shared\PathLookupHelper.cs (6)

tests\Aspire.TestUtilities\PlatformDetection.cs (3)

8public static bool IsRunningOnAzdoBuildMachine => Environment.GetEnvironmentVariable("BUILD_BUILDID") is not null; 9public static bool IsRunningOnHelix => Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT") is not null; 10public static bool IsRunningOnGithubActions => Environment.GetEnvironmentVariable("GITHUB_JOB") is not null;

tests\Aspire.TestUtilities\RequiresFeatureAttribute.cs (1)

54if (Environment.GetEnvironmentVariable("PLAYWRIGHT_INSTALLED") is var playwrightInstalled && !string.IsNullOrEmpty(playwrightInstalled))

tests\Aspire.TestUtilities\TestcontainersPodmanConfiguration.cs (5)

74Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), 75Environment.GetEnvironmentVariable, 87Environment.SetEnvironmentVariable(DockerHostVariable, dockerHost); 92Environment.SetEnvironmentVariable(RyukDisabledVariable, "true");

tests\Shared\Logging\XunitLoggerProvider.cs (3)

tests\Shared\Playwright\PlaywrightProvider.cs (3)

Aspire.Templates.Tests (28)

tests\Shared\Playwright\PlaywrightProvider.cs (3)

tests\Shared\TemplatesTesting\AspireProject.cs (3)

tests\Shared\TemplatesTesting\BuildEnvironment.cs (9)

tests\Shared\TemplatesTesting\CommandResult.cs (2)

32_ = message.AppendLine(CultureInfo.InvariantCulture, $"{Environment.NewLine}Standard Output:{Environment.NewLine}{Output}");

tests\Shared\TemplatesTesting\EnvironmentVariables.cs (10)

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

203return string.Join(System.Environment.NewLine, outputLines);

Aspire.TerminalHost (9)

src\Shared\ParentProcessWatchdog.cs (3)

src\Shared\ProcessStartTimeHelper.cs (1)

62if (TryGetProcessStartTime(Environment.ProcessId) is { } startTime)

TerminalHostApp.cs (2)

284$"[Aspire.TerminalHost] startup pid={Environment.ProcessId} otel=on endpoint='{otlpEndpoint}' protocol='{otlpProtocol}' headers.len={otlpHeaders?.Length ?? 0} service='{serviceName}' resource='{resourceAttrs}'") 315Environment.ProcessId, otlpEndpoint, otlpProtocol, serviceName);

TerminalHostProcessRunner.cs (1)

41Environment.Exit);

TerminalReplica.cs (2)

575var deadline = Environment.TickCount64 + 2_000; 578while (Environment.TickCount64 < deadline && !ct.IsCancellationRequested)

Aspire.TestTools (3)

GitHubCli.cs (2)

215var fixtureDirectory = Environment.GetEnvironmentVariable(FixtureDirectoryEnvironmentVariable); 373var fixtureDirectory = Environment.GetEnvironmentVariable(FixtureDirectoryEnvironmentVariable);

TrxReader.cs (1)

237Environment.NewLine,

Aspire.TestUtilities (15)

PlatformDetection.cs (3)

RequiresFeatureAttribute.cs (1)

54if (Environment.GetEnvironmentVariable("PLAYWRIGHT_INSTALLED") is var playwrightInstalled && !string.IsNullOrEmpty(playwrightInstalled))

src\Shared\PathLookupHelper.cs (6)

TestcontainersPodmanConfiguration.cs (5)

CertManagerDemo.ApiService (10)

Program.cs (10)

24machineName = Environment.MachineName, 25podIp = Environment.GetEnvironmentVariable("POD_IP"), 47machineName = Environment.MachineName, 48osVersion = Environment.OSVersion.ToString(), 49processorCount = Environment.ProcessorCount, 50dotnetVersion = Environment.Version.ToString(), 51aspnetcoreEnv = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"), 52podIp = Environment.GetEnvironmentVariable("POD_IP"), 53podName = Environment.GetEnvironmentVariable("POD_NAME"), 54nodeName = Environment.GetEnvironmentVariable("NODE_NAME")

Client.TypedClient.IntegrationTests (3)

TypedProxyTests.4.0.0.cs (3)

192int startThread = Environment.CurrentManagedThreadId; 195Assert.True(startThread == Environment.CurrentManagedThreadId, String.Format("Expected continuation to happen on thread {0} but actually continued on thread {1}", 196startThread, Environment.CurrentManagedThreadId));

CodeStyleConfigFileGenerator (3)

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

crossgen2 (4)

Crossgen2RootCommand.cs (2)

378var parallelism = Math.Min(24, Environment.ProcessorCount); 381if (!Environment.Is64BitProcess)

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

181details.Add(Environment.GetCommandLineArgs()[0]); 186details.Add(System.Diagnostics.FileVersionInfo.GetVersionInfo(Environment.GetCommandLineArgs()[0]).ToString());

Crossgen2Tasks (4)

CommonFilePulledFromSdkRepo\TaskBase.cs (4)

70Environment.NewLine, 74Environment.NewLine); 95s = s + " ---> " + ExceptionToStringWithoutMessage(e.InnerException) + Environment.NewLine + 104s += Environment.NewLine + stackTrace;

csc (14)

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

151var libDirectory = Environment.GetEnvironmentVariable("LIB"); 222CompilerOptionParseUtilities.PrependFeatureFlagFromEnvironment(buildRequestArguments, Environment.GetEnvironmentVariable, _logger.Log);

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

228var originalThreadId = Environment.CurrentManagedThreadId; 289var releaseThreadId = Environment.CurrentManagedThreadId; 528var environmentVariables = new Dictionary<string, string>(Environment.EnvironmentVariableComparer); 536if (dotNetRoot != null && key.StartsWith(RuntimeHostInfo.DotNetRootEnvironmentName, Environment.EnvironmentVariableComparison)) 704var userName = Environment.UserName;

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

146var threadId = Environment.CurrentManagedThreadId; 148string output = prefix + message + Environment.NewLine;

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

18: base(CSharpCommandLineParser.Default, responseFile, args, buildPaths, Environment.GetEnvironmentVariable("LIB"), analyzerLoader)

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

58Environment.FailFast(message);

src\roslyn\src\Compilers\Shared\StandardBuildEnvironment.cs (3)

22public string? GetEnvironmentVariable(string name) => Environment.GetEnvironmentVariable(name); 28var environmentVariables = Environment.GetEnvironmentVariables(); 29var map = new Dictionary<string, string>(capacity: environmentVariables.Count, Environment.EnvironmentVariableComparer);

CSharpSyntaxGenerator (10)

Grammar\GrammarGenerator.cs (7)

95var result = "// <auto-generated />" + Environment.NewLine + "grammar csharp;" + Environment.NewLine; 109result += Environment.NewLine + RuleReference(name).Text + Environment.NewLine + " : " + 110string.Join(Environment.NewLine + " | ", sorted) + Environment.NewLine + " ;" + Environment.NewLine;

Program.cs (3)

172text = text.Replace($"{{{Environment.NewLine}{Environment.NewLine}", $"{{{Environment.NewLine}");

datacollector (8)

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

36var debugEnabled = Environment.GetEnvironmentVariable(environmentVariable); 55Environment.ProcessId; 76var vsAttachPath = Environment.GetEnvironmentVariable(env) ?? FindAttachVs(); 79Environment.SetEnvironmentVariable(env, vsAttachPath); 104var paths = Environment.GetEnvironmentVariable("PATH")!.Split(';'); 127var debugEnabled = Environment.GetEnvironmentVariable(environmentVariable); 154var nativeDebugEnabled = Environment.GetEnvironmentVariable(environmentVariable); 180return Environment.GetEnvironmentVariable("VSTEST_DEBUG_NOBP")?.Equals("1") ?? false;

datacollector.arm64 (8)

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

dotnet (4)

Program.cs (4)

14var pidPath = Environment.GetEnvironmentVariable("ASPIRE_TEST_HANG_PID_PATH") 16File.WriteAllText(pidPath, Environment.ProcessId.ToString(CultureInfo.InvariantCulture)); 50Environment.ExitCode = 42; 58var capturePath = Environment.GetEnvironmentVariable("ASPIRE_TEST_CAPTURE_PATH")

dotnet-aot (72)

NativeEntryPoint.cs (2)

153globalJsonState = NativeWrapper.NETCoreSdkResolverNativeWrapper.GetGlobalJsonState(Environment.CurrentDirectory); 181if (EnvironmentVariableParser.ParseBool(Environment.GetEnvironmentVariable(EnvironmentVariableNames.DOTNET_CLI_ENABLEAOT), defaultValue: true))

parent\dotnet\CommandFactory\CommandResolution\WindowsExePreferredCommandSpecFactory.cs (3)

51var comSpec = Environment.GetEnvironmentVariable("ComSpec") ?? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "cmd.exe");

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

54currentDirectory ??= Environment.CurrentDirectory; 168if (rootVariableName is not null && string.IsNullOrEmpty(Environment.GetEnvironmentVariable(rootVariableName)))

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

42_exitAction = exitAction ?? Environment.Exit;

parent\dotnet\Commands\Test\MTP\IPC\Serializers\UnknownMessageSerializer.cs (1)

18=> Environment.FailFast("SDK never serializes UnknownMessage. This should never be hit.");

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

57_traceFilePath = Environment.GetEnvironmentVariable(CliConstants.TestTraceLoggingEnvVar);

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

685string? environmentValue = Environment.GetEnvironmentVariable(TestingPlatformExitCodeIgnoreEnvironmentVariable); 1024bool inCI = string.Equals(Environment.GetEnvironmentVariable("TF_BUILD"), "true", StringComparison.OrdinalIgnoreCase) || string.Equals(Environment.GetEnvironmentVariable("GITHUB_ACTIONS"), "true", StringComparison.OrdinalIgnoreCase); 1197degreeOfParallelism = Environment.ProcessorCount;

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

78acceptAnsiColorCodes = AnsiDetector.IsAnsiSupported(Environment.GetEnvironmentVariable("TERM"));

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

578Environment.GetEnvironmentVariable(CliConstants.TestArtifactPostProcessingTimeoutEnvVar)); 622Environment.FailFast(exAsString); 803Environment.FailFast(exAsString); 858{ HandshakeMessagePropertyNames.PID, Environment.ProcessId.ToString(CultureInfo.InvariantCulture) }, 977outputToWrite = line + Environment.NewLine; 1037return _liveStreamingEnabled ? string.Empty : string.Join(Environment.NewLine, _lines); 1050return string.Join(Environment.NewLine, _lines);

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

593=> text.EndsWith('\n') ? text : text + Environment.NewLine;

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

32string vsTestConsolePath = Environment.GetEnvironmentVariable("VSTEST_CONSOLE_PATH");

parent\dotnet\Commands\Test\VSTest\VSTestTrace.cs (2)

15TraceEnabled = int.TryParse(Environment.GetEnvironmentVariable("DOTNET_CLI_VSTEST_TRACE"), out int enabled) && enabled == 1; 16s_traceFilePath = Environment.GetEnvironmentVariable("DOTNET_CLI_VSTEST_TRACEFILE");

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

44Environment.NewLine,

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

59private readonly Func<string, string?> _getEnvironmentVariable = getEnvironmentVariable ?? Environment.GetEnvironmentVariable;

parent\dotnet\Commands\Workload\Install\WorkloadManifestUpdater.cs (3)

35var dotnetPath = Path.GetDirectoryName(Environment.ProcessPath); 38var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, sdkVersion, userProfileDir, SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory)); 96var backgroundUpdatesDisabled = bool.TryParse(Environment.GetEnvironmentVariable(EnvironmentVariableNames.WORKLOAD_UPDATE_NOTIFY_DISABLE), out var disableEnvVar) && disableEnvVar;

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

45DotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath)!; 56userProfileDir, SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory)); 195var dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);

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

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

parent\dotnet\Extensions\ParseResultExtensions.cs (1)

158message: string.Join(Environment.NewLine, parseResult.Errors.Select(e => e.Message)),

parent\dotnet\MsbuildProject.cs (3)

207originalDotnetHostPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH"); 208Environment.SetEnvironmentVariable("DOTNET_HOST_PATH", new Muxer().MuxerPath); 227Environment.SetEnvironmentVariable("DOTNET_HOST_PATH", originalDotnetHostPath);

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

153commandOutput = commandResult.StdOut + Environment.NewLine + commandResult.StdErr;

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

101|| (bool.TryParse(Environment.GetEnvironmentVariable(NuGetSignatureVerificationEnabler.DotNetNuGetSignatureVerification), out var shouldVerifySignature)

parent\dotnet\SdkVulnerability\SdkReleaseMetadataCache.cs (1)

29Environment.GetEnvironmentVariable)

parent\dotnet\ShellShim\LinuxEnvironmentPath.cs (1)

21Environment.GetEnvironmentVariable("DOTNET_CLI_TEST_LINUX_PROFILED_PATH") ??

parent\dotnet\ShellShim\OsxBashEnvironmentPath.cs (1)

25internal static readonly string DotnetCliToolsPathsDPath = Environment.GetEnvironmentVariable("DOTNET_CLI_TEST_OSX_PATHSD_PATH") ?? @"/etc/paths.d/dotnet-cli-tools";

parent\dotnet\Telemetry\DevDeviceIDGetter.cs (10)

53string xdgCacheHome = Environment.GetEnvironmentVariable("XDG_CACHE_HOME"); 60cacheFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".cache", "deviceid"); 71string cacheFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library", "Application Support", "Microsoft", "DeveloperTools", "deviceid"); 101string xdgCacheHome = Environment.GetEnvironmentVariable("XDG_CACHE_HOME"); 108cacheFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".cache", "deviceid"); 116string cacheFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library", "Application Support", "Microsoft", "DeveloperTools", "deviceid");

parent\dotnet\Telemetry\ExternalTelemetryProperties.cs (2)

60if (GetProductInfo((uint)Environment.OSVersion.Version.Major, (uint)Environment.OSVersion.Version.Minor, 0, 0, out uint productType))

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

65{ TelemetryProfile, Environment.GetEnvironmentVariable(TelemetryProfileEnvironmentVariable) },

parent\dotnet\Telemetry\TelemetryFilter.cs (4)

156Environment.NewLine, 160Environment.NewLine); 179s = s + " ---> " + ExceptionToStringWithoutMessage(e.InnerException) + Environment.NewLine + 186s += Environment.NewLine + stackTrace;

parent\dotnet\ToolManifest\ToolManifestEditor.cs (2)

282var joinedWithIndentation = string.Join(Environment.NewLine, 303string.Join(Environment.NewLine, errors.Select(e => "\t" + e))));

parent\dotnet\ToolManifest\ToolManifestFinder.cs (4)

31_getEnvironmentVariable = getEnvironmentVariable ?? Environment.GetEnvironmentVariable; 44throw new ToolManifestCannotBeFoundException(string.Format(CliStrings.CannotFindAManifestFile, string.Join(Environment.NewLine, allPossibleManifests.Select(f => "\t" + f.manifestfile.Value)))); 210throw new ToolManifestCannotBeFoundException(string.Format(CliStrings.CannotFindAManifestFile, string.Join(Environment.NewLine, EnumerateDefaultAllPossibleManifests().Select(f => "\t" + f.manifestfile.Value)))); 297throw new ToolManifestCannotBeFoundException(string.Format(CliStrings.CannotFindAManifestFile, string.Join(Environment.NewLine, EnumerateDefaultAllPossibleManifests().Select(f => "\t" + f.manifestfile.Value))));

src\sdk\src\Common\CliFolderPathCalculatorCore.cs (3)

17: this(Environment.GetEnvironmentVariable) 59home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

src\sdk\src\Common\EnvironmentVariableNames.cs (2)

68=> TryGetDotNetRootVariableNameImpl(runtimeIdentifier, defaultAppHostRuntimeIdentifier, targetFrameworkVersion, RuntimeInformation.ProcessArchitecture, Environment.Is64BitProcess); 89=> TryGetDotNetRootVariableNameImpl(runtimeIdentifier, defaultAppHostRuntimeIdentifier, null, RuntimeInformation.ProcessArchitecture, Environment.Is64BitProcess, onlyUseArchSpecific: true);

dotnet-dev-certs (25)

Program.cs (3)

405"already trusted we will run the following command:" + Environment.NewLine + 407Environment.NewLine + "This command might prompt you for your password to install the certificate " + 408"on the keychain. To undo these changes: 'security remove-trusted-cert <<certificate>>'" + Environment.NewLine);

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

1042return string.Join(Environment.NewLine, description);

src\aspnetcore\src\Shared\CertificateGeneration\MacOSCertificateManager.cs (4)

26private static readonly string MacOSUserKeychain = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "/Library/Keychains/login.keychain-db"; 34private static readonly string MacOSUserHttpsCertificateLocation = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".aspnet", "dev-certs", "https");

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

62if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable(OpenSslCertDirectoryOverrideVariableName))) 102var sslCertDirString = Environment.GetEnvironmentVariable(OpenSslCertificateDirectoryVariableName); 137var nssDbs = GetNssDbs(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)); 233var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 367var existingSslCertDir = Environment.GetEnvironmentVariable(OpenSslCertificateDirectoryVariableName); 464var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)!; 593var searchPath = Environment.GetEnvironmentVariable("PATH"); 653if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("WSL_INTEROP"))) 806var @override = Environment.GetEnvironmentVariable(OpenSslCertDirectoryOverrideVariableName); 832var nssDbOverride = Environment.GetEnvironmentVariable(NssDbOverrideVariableName); 879Log.UnixHomeDirectoryDoesNotExist(homeDirectory, Environment.UserName);

src\aspnetcore\src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

48if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix")))

src\aspnetcore\src\Tools\Shared\CommandLine\CliContext.cs (1)

20bool.TryParse(Environment.GetEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE"), out bool globalVerbose);

src\aspnetcore\src\Tools\Shared\CommandLine\DebugHelper.cs (1)

24Console.WriteLine($"Process ID: {Environment.ProcessId}");

dotnet-format (7)

Commands\FormatCommandCommon.cs (2)

246Environment.Exit(CheckFailedExitCode); 312var currentDirectory = Environment.CurrentDirectory;

Formatters\EndOfLineFormatter.cs (2)

84_ => Environment.NewLine, 95_ => GetEndOfLineOption(Environment.NewLine),

Formatters\FinalNewlineFormatter.cs (1)

35endOfLine = Environment.NewLine;

ReportWriter.cs (1)

41return Path.Combine(Environment.CurrentDirectory, defaultReportName);

Utilities\DotNetHelper.cs (1)

15logger.LogDebug(string.Join(Environment.NewLine, restoreResult.OutputLines));

dotnet-getdocument (5)

parent\parent\GetDocumentInsider\src\ReporterExtensions.cs (2)

31Environment.NewLine, 33.Split(new[] { Environment.NewLine }, StringSplitOptions.None)

src\aspnetcore\src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

48if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix")))

src\aspnetcore\src\Tools\Shared\CommandLine\CliContext.cs (1)

20bool.TryParse(Environment.GetEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE"), out bool globalVerbose);

src\aspnetcore\src\Tools\Shared\CommandLine\DebugHelper.cs (1)

24Console.WriteLine($"Process ID: {Environment.ProcessId}");

dotnet-Microsoft.XmlSerializer.Generator (1)

Sgen.cs (1)

322outputDirectory ??= (gac ? Environment.CurrentDirectory : Path.GetDirectoryName(assembly.Location));

dotnet-openapi (4)

DebugMode.cs (1)

19Console.WriteLine("Waiting for debugger in pid: {0}", Environment.ProcessId);

src\aspnetcore\src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

48if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix")))

src\aspnetcore\src\Tools\Shared\CommandLine\CliContext.cs (1)

20bool.TryParse(Environment.GetEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE"), out bool globalVerbose);

src\aspnetcore\src\Tools\Shared\CommandLine\DebugHelper.cs (1)

24Console.WriteLine($"Process ID: {Environment.ProcessId}");

dotnet-razorpagegenerator (2)

Program.cs (2)

130var diagnostics = string.Join(Environment.NewLine, cSharpDocument.Diagnostics); 131Console.WriteLine($"One or more parse errors encountered. This will not prevent the generator from continuing: {Environment.NewLine}{diagnostics}.");

dotnet-sourcelink (3)

Program.cs (3)

164_parseResult.InvocationConfiguration.Error.Write(Environment.NewLine); 171_parseResult.InvocationConfiguration.Output.Write(Environment.NewLine); 193parseResult.InvocationConfiguration.Error.Write(Environment.NewLine);

dotnet-sql-cache (3)

src\aspnetcore\src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

48if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix")))

src\aspnetcore\src\Tools\Shared\CommandLine\CliContext.cs (1)

20bool.TryParse(Environment.GetEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE"), out bool globalVerbose);

src\aspnetcore\src\Tools\Shared\CommandLine\DebugHelper.cs (1)

24Console.WriteLine($"Process ID: {Environment.ProcessId}");

dotnet-suggest (4)

DotnetProfileDirectory.cs (2)

20var home = Environment.GetEnvironmentVariable(DotnetHomeVariableName); 23home = Environment.GetEnvironmentVariable(PlatformHomeVariableName);

FileSuggestionRegistration.cs (1)

7using static System.Environment;

SuggestionDispatcher.cs (1)

182return string.Join(Environment.NewLine, Prefixes());

dotnet-svcutil-lib (70)

AppInsightsTelemetryClient.cs (3)

31string optOut = Environment.GetEnvironmentVariable(OptOutVariable); 79if (!bool.TryParse(Environment.GetEnvironmentVariable(testModeVariable), out bool testMode)) 115context.User.Id = GetStableHashCode(Environment.UserName).ToString();

Bootstrapper\SvcutilBootstrapper.cs (1)

207throw new BootstrapException(string.Format(CultureInfo.CurrentCulture, "{0}{1}{2}", exception.Message, Environment.NewLine, Resource.BootstrapErrorDisableReferences));

CmdCredentialsProvider.cs (1)

250return separator + Environment.NewLine + certId + cert + separator;

CodeDomFixup\MethodCreationHelper.cs (6)

111indent + "{0} <summary>" + Environment.NewLine + 112indent + "{0} " + SR.ConfigureEndpointCommentSummary + Environment.NewLine + 113indent + "{0} </summary>" + Environment.NewLine + 114indent + "{0} <param name=\"serviceEndpoint\">" + SR.ServiceEndpointComment + "</param>" + Environment.NewLine + 115indent + "{0} <param name=\"clientCredentials\">" + SR.ClientCredentialsComment + "</param>" + Environment.NewLine; 127indent + "Partial Private Shared Sub ConfigureEndpoint(ByVal serviceEndpoint As System.ServiceModel.Description.ServiceEndpoint, ByVal clientCredentials As System.ServiceModel.Description.ClientCredentials)" + Environment.NewLine +

CommandLineParser.cs (1)

141SetValue(options, CommandProcessorOptions.InputsKey, Environment.ExpandEnvironmentVariables(arg));

CommandProcessorOptions.cs (1)

363throw new ToolArgumentException($"{moreThanOneProjectMsg}{Environment.NewLine}{useProjectOptions}");

FrameworkFork\Microsoft.CodeDom\Compiler\RedistVersionInfo.cs (2)

47string comPlus_InstallRoot = Environment.GetEnvironmentVariable("COMPLUS_InstallRoot"); 48string comPlus_Version = Environment.GetEnvironmentVariable("COMPLUS_Version");

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

499b.Append(Environment.NewLine);

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

518b.Append(Environment.NewLine);

FrameworkFork\Microsoft.Xml\Xml\Core\SecureStringHasher.cs (1)

38_hashCodeRandomizer = Environment.TickCount;

FrameworkFork\Microsoft.Xml\Xml\Core\XmlWriterSettings.cs (1)

691_newLineChars = Environment.NewLine; // "\r\n" on Windows, "\n" on Unix

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

56_hashCodeRandomizer = Environment.TickCount;

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

196_w.Append(Environment.NewLine);

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

1680if (methodName == null) throw new InvalidOperationException(string.Format(ResXml.XmlInternalErrorMethod, mapping.TypeDesc.Name) + Environment.StackTrace); 2254if (methodName == null) throw new InvalidOperationException("deriaved from " + mapping.TypeDesc.FullName + ", " + string.Format(ResXml.XmlInternalErrorMethod, derived.TypeDesc.Name) + Environment.StackTrace); 2292if (methodName == null) throw new InvalidOperationException(string.Format(ResXml.XmlInternalErrorMethod, mapping.TypeDesc.Name) + Environment.StackTrace); 3376if (methodName == null) throw new InvalidOperationException(string.Format(ResXml.XmlInternalErrorMethod, mapping.TypeDesc.Name) + Environment.StackTrace);

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

132if (methodName == null) throw new InvalidOperationException(string.Format(ResXml.XmlInternalErrorMethod, mapping.TypeDesc.Name) + Environment.StackTrace); 772if (methodName == null) throw new InvalidOperationException("deriaved from " + mapping.TypeDesc.FullName + ", " + string.Format(ResXml.XmlInternalErrorMethod, derived.TypeDesc.Name) + Environment.StackTrace); 823if (methodName == null) throw new InvalidOperationException(string.Format(ResXml.XmlInternalErrorMethod, mapping.TypeDesc.Name) + Environment.StackTrace); 2111if (methodName == null) throw new InvalidOperationException(string.Format(ResXml.XmlInternalErrorMethod, mapping.TypeDesc.Name) + Environment.StackTrace);

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

468errorMessage.AppendFormat("{0}\"{1}\" ", Environment.NewLine, conflictingType.AssemblyQualifiedName);

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

42Environment.FailFast(message);

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

170Environment.FailFast(failFastMessage);

FrameworkFork\System.ServiceModel\Internals\System\Runtime\SynchronizedPool.cs (3)

211int thisThreadID = Environment.CurrentManagedThreadId; 264int thisThreadID = Environment.CurrentManagedThreadId; 339return Environment.ProcessorCount;

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

284uint currentTime = (uint)Environment.TickCount;

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

424Environment.NewLine,

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TransportDefaults.cs (3)

214return 12 * Environment.ProcessorCount; 219return 2 * Environment.ProcessorCount; 235return 12 * Environment.ProcessorCount;

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

41public static readonly long MaxPendingMessagesTotalSize = 1024 * 1024 * Environment.ProcessorCount; // 512 * 2K messages per processor

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\DataProtectionSecurityStateEncoder.cs (2)

62result.AppendFormat("{0} UseCurrentUserProtectionScope={1}", Environment.NewLine, _useCurrentUserProtectionScope); 63result.AppendFormat("{0} Entropy Length={1}", Environment.NewLine, (_entropy == null) ? 0 : _entropy.Length);

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\TimeBoundedCache.cs (3)

308Environment.FailFast("Cache write lock is not held."); 370Environment.FailFast("Cache write lock is not held."); 387Environment.FailFast("Cache write lock is not held.");

HelpGenerator.cs (4)

365index += Environment.NewLine.Length; 422if ((index + Environment.NewLine.Length) > text.Length) 427for (int i = 0; i < Environment.NewLine.Length; i++) 429if (Environment.NewLine[i] != text[index + i])

Metadata\MetadaExchangeResolver.cs (1)

347_currentRequest.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; MS Web Services Client Protocol " + System.Environment.Version.ToString() + ")";

Shared\Options\OptionsSerializer.cs (1)

205var separator = prettyFormat ? Environment.NewLine : " ";

Shared\ProjectPropertyResolver.cs (1)

98await safeLogger.WriteErrorAsync($"{ex.Message}{Environment.NewLine}{ex.StackTrace}", logToUI: false);

Shared\Utilities\DebugUtils.cs (4)

19set { Environment.SetEnvironmentVariable(SvcutilKeepBootstrapDirEnvVar, value ? "1" : string.Empty); } 20get { return Int32.TryParse(Environment.GetEnvironmentVariable(SvcutilKeepBootstrapDirEnvVar), out int ret) ? (ret > 0 ? true : false) : false; } 30set { Environment.SetEnvironmentVariable(SvcutilDebugVariableEnvVar, value.ToString(CultureInfo.InvariantCulture)); } 31get { return Int32.TryParse(Environment.GetEnvironmentVariable(SvcutilDebugVariableEnvVar), out int ret) ? ret : 0; }

Shared\Utilities\ProcessRunner.cs (2)

66using (var safeLogger = await SafeLogger.WriteStartOperationAsync(logger, $"Executing command [\"{currentDir}\"]{Environment.NewLine}>{processName} {processArgs}").ConfigureAwait(false)) 115Console.WriteLine($"{Path.GetFileName(currentDir)}>{processName} {processArgs}{Environment.NewLine}");

Shared\Utilities\RuntimeEnvironmentHelper.cs (6)

62"<?xml version=\"1.0\" encoding=\"utf-8\"?>" + Environment.NewLine + 63"<configuration>" + Environment.NewLine + 64" <packageSources>" + Environment.NewLine + 65" <add key = \"svcutilFeed\" value=\"{0}\" />" + Environment.NewLine + 66" </packageSources>" + Environment.NewLine + 67"</configuration>" + Environment.NewLine;

Shared\Utilities\Utilities.cs (1)

43message.Append(string.Concat(Environment.NewLine, exMsg, includeStackTrace ? e.StackTrace : string.Empty));

ToolConsole.cs (4)

128str = str.Replace("\\r\\n", Environment.NewLine); 135str = logTag + str.Replace(Environment.NewLine, newLineReplacement); 166WriteWarning(conversionError.Message.Replace("\r\n", Environment.NewLine).Trim(trimLFNL)); 170WriteError(conversionError.Message.Replace("\r\n", Environment.NewLine).Trim(trimLFNL));

dotnet-svcutil-lib.Tests (84)

E2ETests.cs (1)

54_ = $"{processResult.OutputText}{Environment.NewLine}{((TestLogger)this_TestCaseLogger)}";

FixupUtil.cs (3)

15static readonly string s_programFilesx64 = Environment.GetEnvironmentVariable("ProgramW6432")?.Replace('\\', '/'); 44new ReplaceInfo(Environment.GetEnvironmentVariable("USERPROFILE"), "$USERPROFILE$"), 86_replacements.Add(new ReplaceInfo(Environment.GetEnvironmentVariable("HOME"), "$USERPROFILE$"));

GlobalToolTests.cs (1)

23var outputText = $"{processResult.OutputText}{Environment.NewLine}{((TestLogger)this_TestCaseLogger)}";

ProjectUtils.cs (2)

73Assert.True(ret.ExitCode == 0, $"Project package restore failed:{Environment.NewLine}{ret.OutputText}{logger}"); 78Assert.True(ret.ExitCode == 0, $"Project build failed:{Environment.NewLine}{ret.OutputText}{logger}");

TestInit.cs (44)

TestLogger.cs (1)

13static readonly string programFilesx64 = Environment.GetEnvironmentVariable("ProgramW6432")?.Replace('\\', '/');

UnitTest.cs (32)

dotnet-svcutil.xmlserializer (5)

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

69System.Environment.Exit((int)ToolExitCodes.Unknown);

Microsoft\Tools\ServiceModel\SvcUtil\ToolConsole.cs (4)

542index += Environment.NewLine.Length; 599if ((index + Environment.NewLine.Length) > text.Length) 604for (int i = 0; i < Environment.NewLine.Length; i++) 606if (Environment.NewLine[i] != text[index + i])

dotnet-user-jwts (16)

Commands\CreateCommand.cs (12)

src\aspnetcore\src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

48if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix")))

src\aspnetcore\src\Tools\Shared\CommandLine\CliContext.cs (1)

20bool.TryParse(Environment.GetEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE"), out bool globalVerbose);

src\aspnetcore\src\Tools\Shared\CommandLine\DebugHelper.cs (1)

24Console.WriteLine($"Process ID: {Environment.ProcessId}");

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

64propertyGroup.Add($"{Environment.NewLine} ");

dotnet-user-secrets (4)

src\aspnetcore\src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

48if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix")))

src\aspnetcore\src\Tools\Shared\CommandLine\CliContext.cs (1)

20bool.TryParse(Environment.GetEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE"), out bool globalVerbose);

src\aspnetcore\src\Tools\Shared\CommandLine\DebugHelper.cs (1)

24Console.WriteLine($"Process ID: {Environment.ProcessId}");

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

64propertyGroup.Add($"{Environment.NewLine} ");

dotnet-watch (1)

Program.cs (1)

50Environment.SetEnvironmentVariable(EnvironmentVariables.Names.DotnetHostPath, environmentOptions.GetMuxerPath());

DotNetHostedAgent (7)

DevTemporaryLocalUserIdProvider.cs (1)

31: Environment.GetEnvironmentVariable(UserIdEnvironmentVariable);

Program.cs (6)

13string projectConnectionString = Environment.GetEnvironmentVariable("ConnectionStrings__projmyproject") 16string chatConnectionString = Environment.GetEnvironmentVariable("ConnectionStrings__chat") 52Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"), 58var searchAgentReference = new AgentReference(name: Environment.GetEnvironmentVariable("SEARCHAGENT_AGENTNAME")); 60var searchAgent = responseClient.AsIChatClient(deploymentName).AsAIAgent(Environment.GetEnvironmentVariable("SEARCHAGENT_AGENTNAME"), description: "I can search the web."); 70string port = Environment.GetEnvironmentVariable("DEFAULT_AD_PORT") ?? "8088";

DotNetInvocationHostedAgent (1)

Program.cs (1)

8builder.WebHost.UseUrls($"http://+:{Environment.GetEnvironmentVariable("DEFAULT_AD_PORT") ?? "8088"}");

DotnetProject.WorkerService (1)

Program.cs (1)

19return $"{Greeter.Greet("workerservice")}{Environment.NewLine}Upstream apiservice said: {upstream}";

EventHubsConsumer (1)

Program.cs (1)

9bool useConsumer = Environment.GetEnvironmentVariable("USE_EVENTHUBCONSUMERCLIENT") == "yes";

FakeIntegrationLibrary (1)

Program.cs (1)

1var port = Environment.GetEnvironmentVariable("PORT") ?? "0";

GenerateDocumentationAndConfigFiles (21)

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

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (3)

67private int _localRandom = Environment.TickCount; 70private static int s_sharedRandom = Environment.TickCount; 90var pool = new ObjectPool<StringTable>(pool => new StringTable(pool), Environment.ProcessorCount * 2);

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingOptions2.cs (1)

47_ => Environment.NewLine

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\LineFormattingOptions.cs (1)

19[DataMember] public string NewLine { get; init; } = Environment.NewLine;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\RoslynTelemetry_LogBlock.cs (3)

18private static readonly ObjectPool<RoslynLogBlock> s_pool = new(() => new RoslynLogBlock(s_pool!), Math.Min(Environment.ProcessorCount * 8, 256)); 48_tick = Environment.TickCount; 69var delta = Environment.TickCount - _tick;

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

285: reason + Environment.NewLine + restString;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\NonReentrantLock.cs (3)

47/// The <see cref="Environment.CurrentManagedThreadId" /> of the thread that holds the lock. Zero if no thread is holding 193return _owningThreadId == Environment.CurrentManagedThreadId; 204_owningThreadId = Environment.CurrentManagedThreadId;

GetDocument.Insider (7)

Commands\GetDocumentCommandWorker.cs (1)

325writer.WriteLine(string.Join(Environment.NewLine, filePathList));

ReporterExtensions.cs (2)

31Environment.NewLine, 33.Split(new[] { Environment.NewLine }, StringSplitOptions.None)

src\095dea4ec402cc66\HostFactoryResolver.cs (1)

33if (uint.TryParse(Environment.GetEnvironmentVariable(TimeoutEnvironmentKey), out uint timeoutInSeconds))

src\aspnetcore\src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

48if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix")))

src\aspnetcore\src\Tools\Shared\CommandLine\CliContext.cs (1)

20bool.TryParse(Environment.GetEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE"), out bool globalVerbose);

src\aspnetcore\src\Tools\Shared\CommandLine\DebugHelper.cs (1)

24Console.WriteLine($"Process ID: {Environment.ProcessId}");

ilc (4)

ILCompilerRootCommand.cs (2)

403var parallelism = Math.Min(24, Environment.ProcessorCount); 406if (!Environment.Is64BitProcess)

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

181details.Add(Environment.GetCommandLineArgs()[0]); 186details.Add(System.Diagnostics.FileVersionInfo.GetVersionInfo(Environment.GetCommandLineArgs()[0]).ToString());

ILCompiler.DependencyAnalysisFramework (1)

DependencyAnalyzer.cs (1)

109if (int.TryParse(Environment.GetEnvironmentVariable("CoreRT_DeterminismSeed"), out int seed))

ILCompiler.ReadyToRun (3)

PortableCallHelpers\PInvokeTableGenerator.cs (2)

104string imports = string.Join(Environment.NewLine, 109$" Managed DllImports: {Environment.NewLine}{imports}");

PortableCallHelpers\PortableCallHelpersGenerator.cs (1)

142var buffer = new StringWriter { NewLine = Environment.NewLine };

illink (1)

Linker.Steps\OutputStep.cs (1)

200if (Environment.OSVersion.Platform != PlatformID.Win32NT && assembly.MainModule.SymbolReader.GetType().FullName == "Mono.Cecil.Pdb.NativePdbReader")

ILLink.Tasks (1)

LinkTask.cs (1)

246_dotnetPath = Environment.GetEnvironmentVariable(DotNetHostPathEnvironmentName);

Infrastructure.Common (14)

CertificateManager.cs (4)

73return Path.Combine(Environment.CurrentDirectory, "wcfLocal.keychain"); 118exceptionString.AppendFormat("while attempting to install cert with thumbprint '{1}'.", Environment.NewLine, certificate.Thumbprint); 119exceptionString.AppendFormat("{0}This is usually due to permissions issues if writing to the LocalMachine location", Environment.NewLine); 120exceptionString.AppendFormat("{0}Try running the test with elevated or superuser permissions.", Environment.NewLine);

ConditionalTestDetectors.cs (4)

122string computerName = Environment.GetEnvironmentVariable("COMPUTERNAME"); 123string logonServer = Environment.GetEnvironmentVariable("LOGONSERVER"); 124string userDomain = Environment.GetEnvironmentVariable("USERDOMAIN"); 238result = Environment.GetEnvironmentVariable("USERDOMAIN");

ConditionalWcfTest.cs (1)

43string value = Environment.GetEnvironmentVariable(conditionName);

ServiceUtilHelper.cs (3)

120Environment.NewLine, rootCertificate)); 213Environment.NewLine, clientCertificate)); 326Environment.NewLine, peerCertificate));

TestProperties.cs (1)

56? Environment.GetEnvironmentVariable(propertyName)

xunit\WcfTestCase.cs (1)

56timer = new Timer((s) => Environment.FailFast($"Test timed out after duration {_failFastDuration}"),

Infrastructure.IntegrationTests (2)

OSAndFrameworkTests.4.1.1.cs (2)

27Environment.NewLine, 29Environment.NewLine,

Infrastructure.Tests (106)

CreateFailingTestIssue\CreateFailingTestIssueFixture.cs (4)

65$"Failed to build CreateFailingTestIssue tool. Exit code: {process.ExitCode}{Environment.NewLine}" + 66$"stdout:{Environment.NewLine}{stdout}{Environment.NewLine}" + 67$"stderr:{Environment.NewLine}{stderr}");

CreateFailingTestIssue\GitHubCliArgumentTests.cs (3)

53var previousFixtureDirectory = Environment.GetEnvironmentVariable("ASPIRE_FAILING_TEST_ISSUE_FIXTURE_DIR"); 54Environment.SetEnvironmentVariable("ASPIRE_FAILING_TEST_ISSUE_FIXTURE_DIR", null); 69Environment.SetEnvironmentVariable("ASPIRE_FAILING_TEST_ISSUE_FIXTURE_DIR", previousFixtureDirectory);

ExtractTestPartitions\ExtractTestPartitionsTests.cs (1)

342return new ToolResult(process.ExitCode, string.Join(Environment.NewLine, outputLines));

ExtractTestPartitions\MockAssemblyBuilder.cs (2)

274var errors = string.Join(Environment.NewLine, 278throw new InvalidOperationException($"Failed to compile mock assembly:{Environment.NewLine}{errors}");

GenerateTestSummary\GenerateTestSummaryFixture.cs (4)

58$"Failed to build GenerateTestSummary tool. Exit code: {process.ExitCode}{Environment.NewLine}" + 59$"stdout:{Environment.NewLine}{stdout}{Environment.NewLine}" + 60$"stderr:{Environment.NewLine}{stderr}");

Pipelines\ExtensionE2eRecorderStepTests.cs (1)

138return string.Join(Environment.NewLine, [GitHubPwshPrologue, body, GitHubPwshEpilogue]);

Pipelines\NixCliPackageTests.cs (6)

98["PATH"] = fakeBinPath + Path.PathSeparator + Environment.GetEnvironmentVariable("PATH") 101Assert.True(result.ExitCode == 0, $"Expected update-versions.sh to succeed.{Environment.NewLine}{result.Output}"); 160["PATH"] = fakeBinPath + Path.PathSeparator + Environment.GetEnvironmentVariable("PATH") 163Assert.True(result.ExitCode == 0, $"Expected update-versions.sh to succeed in offline mode.{Environment.NewLine}{result.Output}"); 189["PATH"] = Environment.GetEnvironmentVariable("PATH") 192Assert.False(result.ExitCode == 0, $"Expected update-versions.sh to fail with a partial override set.{Environment.NewLine}{result.Output}");

PowerShellScripts\AspireSkillsBundleHashTests.cs (1)

111Assert.True(hash is not null, $"Expected a SHA-512 line in driver output:{Environment.NewLine}{result.Output}");

PowerShellScripts\PowerShellCommand.cs (3)

182return string.Join(System.Environment.NewLine, outputLines); 279message += $"{System.Environment.NewLine}Output:{System.Environment.NewLine}{Output}";

PowerShellScripts\ScanTestPartitionsFromSourceGuardTests.cs (2)

91$"together:{Environment.NewLine}{string.Join(Environment.NewLine, offenders)}");

src\Shared\PathLookupHelper.cs (6)

TestTriggerMap\GraphAffectedProjectsTests.cs (2)

303var items = string.Join(Environment.NewLine, 404var items = string.Join(Environment.NewLine,

TestTriggerMap\SelectTestsCliTests.cs (42)

TestTriggerMap\SelectTestsLayer1IntegrationTests.cs (19)

WorkflowScripts\ExtensionChangelogFinalizedWorkflowTests.cs (1)

481$"git {string.Join(' ', args)} failed with exit code {result.ExitCode}.{Environment.NewLine}{result.Output}");

WorkflowScripts\ExtensionReleaseWorkflowTests.cs (6)

273$"Expected compiled preload script to pass 'bash -n'.{Environment.NewLine}{result.Output}"); 594string.Join(lineEnding ?? Environment.NewLine, commitLines) + (lineEnding ?? Environment.NewLine)); 632$"{pythonExecutable} exited with code {process.ExitCode}.{Environment.NewLine}{stdout}{Environment.NewLine}{stderr}"); 826return new FakeGhFixture(callLogPath, $"{binDirectory}{Path.PathSeparator}{Environment.GetEnvironmentVariable("PATH")}");

WorkflowScripts\NodeCommand.cs (1)

175return string.Join(System.Environment.NewLine, outputLines);

WorkflowScripts\PrDocsCheckWorkflowTests.cs (2)

230$"{python} exited with code {process.ExitCode}.{Environment.NewLine}{stdout}{Environment.NewLine}{stderr}");

installer.tasks (16)

GenerateFileVersionProps.cs (1)

117string.Concat(versionlessFiles.Select(f => Environment.NewLine + f)));

GenerateRunScript.cs (2)

43Log.LogMessage($"Run commands = {string.Join(Environment.NewLine, RunCommands)}"); 65string[] newlineSeparator = new string[] { Environment.NewLine };

StaticFileRegeneration\TpnDocument.cs (6)

31Environment.NewLine, 53Environment.NewLine, 65Preamble + Environment.NewLine + 66string.Join(Environment.NewLine + Environment.NewLine, Sections) + 67Environment.NewLine;

StaticFileRegeneration\TpnSection.cs (2)

23Header + Environment.NewLine + Environment.NewLine + Content;

StaticFileRegeneration\TpnSectionHeader.cs (5)

75SeparatorLine + Environment.NewLine + 76Environment.NewLine + 81Name + Environment.NewLine + 100string name = string.Join(Environment.NewLine, nameLines); 143Name = string.Join(Environment.NewLine, nameLines),

Microsoft.Arcade.Common (8)

CommandFactory.cs (2)

39var comSpec = System.Environment.GetEnvironmentVariable("ComSpec"); 73foreach (var path in System.Environment.GetEnvironmentVariable("PATH").Split(Path.PathSeparator))

CommandResult.cs (4)

37message.AppendLine($"{Environment.NewLine}Standard Output:{Environment.NewLine}{StdOut}"); 42message.AppendLine($"{Environment.NewLine}Standard Error:{Environment.NewLine}{StdErr}");

CompactConsoleLoggerFormatter.cs (2)

47_newLineWithMessagePadding = Environment.NewLine + _messagePadding; 101textWriter.WriteLine(message.Replace(Environment.NewLine, _newLineWithMessagePadding));

Microsoft.AspNetCore (2)

WebApplicationBuilder.cs (2)

281string cwd = System.Environment.CurrentDirectory; 282if (!OperatingSystem.IsWindows() || !string.Equals(cwd, System.Environment.SystemDirectory, StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.App.CodeFixes (1)

Authorization\AddAuthorizationBuilderFixer.cs (1)

122SyntaxFactory.EndOfLine(Environment.NewLine),

Microsoft.AspNetCore.Authentication.Twitter (1)

TwitterHandler.cs (1)

394errorMessageStringBuilder.Append(Environment.NewLine);

Microsoft.AspNetCore.Authorization (4)

LoggingExtensions.cs (4)

24? "Fail() was explicitly called. Authorization failed due to:" + Environment.NewLine + string.Join(Environment.NewLine, failure.FailureReasons.Select(reason => reason.Message)) 29reason = "These requirements were not met:" + Environment.NewLine + string.Join(Environment.NewLine, failure.FailedRequirements);

Microsoft.AspNetCore.Components (4)

Reflection\ComponentProperties.cs (4)

252$"when also used to capture unmatched values. Unmatched values:" + Environment.NewLine + 253string.Join(Environment.NewLine, unmatched.Keys)); 273$"per type can use '{nameof(ParameterAttribute)}.{nameof(ParameterAttribute.CaptureUnmatchedValues)}'. Properties:" + Environment.NewLine + 274string.Join(Environment.NewLine, propertyNames));

Microsoft.AspNetCore.Components.Analyzers (2)

ComponentParameterAnalyzer.cs (2)

130Environment.NewLine, 132Environment.NewLine,

Microsoft.AspNetCore.Components.Endpoints (2)

Rendering\EndpointHtmlRenderer.Streaming.cs (2)

432Environment.GetEnvironmentVariable("DOTNET_MODIFIABLE_ASSEMBLIES") is { Length: > 0 } v1 ? v1 : null; 435Environment.GetEnvironmentVariable("__ASPNETCORE_BROWSER_TOOLS") is { Length: > 0 } v2 ? v2 : null;

Microsoft.AspNetCore.Components.SdkAnalyzers (2)

ComponentParameterAnalyzer.cs (2)

117Environment.NewLine, 119Environment.NewLine,

Microsoft.AspNetCore.Components.Server (1)

src\aspnetcore\src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\SequencePool.cs (1)

55: this(Environment.ProcessorCount * 2, ArrayPool<byte>.Create(80 * 1024, 100))

Microsoft.AspNetCore.Components.Testing (9)

Infrastructure\ParentProcessWatcher.cs (1)

20var pidStr = Environment.GetEnvironmentVariable("TEST_PARENT_PID");

Infrastructure\PlaywrightExtensions.cs (1)

18Environment.GetEnvironmentVariable("PLAYWRIGHT_RECORD_VIDEO"),

Infrastructure\ReadinessNotificationService.cs (1)

24var readyUrl = Environment.GetEnvironmentVariable("E2E_READY_URL");

Infrastructure\ServerInstance.cs (2)

220["TEST_PARENT_PID"] = Environment.ProcessId.ToString(CultureInfo.InvariantCulture), 233var dotnetRoot = Environment.GetEnvironmentVariable("DOTNET_ROOT");

Infrastructure\TestArtifactDirectory.cs (1)

58var overrideDirectory = Environment.GetEnvironmentVariable(EnvironmentVariableName);

Infrastructure\TestReadinessHostingStartup.cs (3)

47var overrideTypeName = Environment.GetEnvironmentVariable("E2E_TEST_SERVICES_TYPE"); 48var overrideMethodName = Environment.GetEnvironmentVariable("E2E_TEST_SERVICES_METHOD"); 87var assemblyName = Environment.GetEnvironmentVariable("ASPNETCORE_HOSTINGSTARTUPASSEMBLIES");

Microsoft.AspNetCore.Components.WebAssembly (6)

Hosting\WebAssemblyCultureProvider.cs (1)

46if (Environment.GetEnvironmentVariable("__BLAZOR_SHARDED_ICU") == "1" &&

Hosting\WebAssemblyHost.cs (2)

171var useOutOfProcessRenderer = Environment.GetEnvironmentVariable("__BLAZOR_WEBASSEMBLY_OUT_OF_PROCESS_RENDERER") == "true"; 177if (Environment.GetEnvironmentVariable("__BLAZOR_WEBASSEMBLY_WAIT_FOR_ROOT_COMPONENTS") == "true")

Rendering\WebAssemblyDispatcher.cs (1)

16public override bool CheckAccess() => _mainManagedThreadId == Environment.CurrentManagedThreadId;

Services\WebAssemblyConsoleLogger.cs (2)

17private static readonly string _newLineWithMessagePadding = Environment.NewLine + _messagePadding; 124logBuilder.Replace(Environment.NewLine, _newLineWithMessagePadding, len, message.Length);

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

ComponentsWebAssemblyApplicationBuilderExtensions.cs (1)

26=> Environment.GetEnvironmentVariable(name) is { Length: > 0 } value ? value : null;

DebugProxyLauncher.cs (2)

43var noProxyEnvVar = Environment.GetEnvironmentVariable("NO_PROXY"); 63var ownerPid = Environment.ProcessId;

src\aspnetcore\src\Shared\CommandLineUtils\Utilities\DotNetMuxer.cs (1)

48if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix")))

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

src\BlazorWebView\src\SharedSource\WebView2WebViewManager.cs (3)

393 string.Join(Environment.NewLine, headers.Select(kvp => $"{kvp.Key}: {kvp.Value}")); 416 Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),

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

src\BlazorWebView\src\SharedSource\WebView2WebViewManager.cs (3)

393 string.Join(Environment.NewLine, headers.Select(kvp => $"{kvp.Key}: {kvp.Value}")); 416 Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),

Microsoft.AspNetCore.Cryptography.Internal (1)

Cng\OSVersionUtil.cs (1)

15if (Environment.OSVersion.Platform is not PlatformID.Win32NT)

Microsoft.AspNetCore.DataProtection (8)

Internal\ContainerUtils.cs (1)

111var value = Environment.GetEnvironmentVariable(envVarName);

Repositories\DefaultKeyStorageDirectories.cs (7)

37var localAppDataFromSystemPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); 38var localAppDataFromEnvPath = Environment.GetEnvironmentVariable("LOCALAPPDATA"); 39var homePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 93if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("WEBSITE_INSTANCE_ID"))) 95var homeEnvVar = Environment.GetEnvironmentVariable("HOME");

Microsoft.AspNetCore.DeveloperCertificates.XPlat (19)

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

1042return string.Join(Environment.NewLine, description);

src\aspnetcore\src\Shared\CertificateGeneration\MacOSCertificateManager.cs (4)

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

Microsoft.AspNetCore.Diagnostics (3)

DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (1)

304.Split(new[] { Environment.NewLine }, StringSplitOptions.None);

src\aspnetcore\src\Shared\Diagnostics\BaseView.cs (1)

293return string.Join(" " + Environment.NewLine,

src\aspnetcore\src\Shared\RazorViews\BaseView.cs (1)

283return string.Join(" " + Environment.NewLine,

Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore (2)

src\aspnetcore\src\Shared\Diagnostics\BaseView.cs (1)

293return string.Join(" " + Environment.NewLine,

src\aspnetcore\src\Shared\RazorViews\BaseView.cs (1)

283return string.Join(" " + Environment.NewLine,

Microsoft.AspNetCore.Grpc.JsonTranscoding (1)

parent\Shared\X509CertificateHelpers.cs (1)

117Environment.NewLine,

Microsoft.AspNetCore.Hosting (9)

Internal\HostingLoggerExtensions.cs (1)

35message = message + Environment.NewLine + ex.Message;

Internal\HostingTelemetryHelpers.cs (1)

42CreateKnownHttpMethods(Environment.GetEnvironmentVariable(KnownHttpMethodsEnvironmentVariable));

src\aspnetcore\src\Shared\RazorViews\BaseView.cs (1)

283return string.Join(" " + Environment.NewLine,

WebHostBuilder.cs (6)

50UseSetting(WebHostDefaults.EnvironmentKey, Environment.GetEnvironmentVariable("Hosting:Environment") 51?? Environment.GetEnvironmentVariable("ASPNET_ENV")); 57UseSetting(WebHostDefaults.ServerUrlsKey, Environment.GetEnvironmentVariable("ASPNETCORE_SERVER.URLS")); 146if (Environment.GetEnvironmentVariable("Hosting:Environment") != null) 151if (Environment.GetEnvironmentVariable("ASPNET_ENV") != null) 156if (Environment.GetEnvironmentVariable("ASPNETCORE_SERVER.URLS") != null)

Microsoft.AspNetCore.Html.Abstractions (6)

HtmlContentBuilderExtensions.cs (4)

70/// Appends an <see cref="Environment.NewLine"/>. 83/// Appends an <see cref="Environment.NewLine"/> after appending the <see cref="string"/> value. 99/// Appends an <see cref="Environment.NewLine"/> after appending the <see cref="IHtmlContent"/> value. 114/// Appends an <see cref="Environment.NewLine"/> after appending the <see cref="string"/> value.

HtmlString.cs (2)

14/// An <see cref="HtmlString"/> instance for <see cref="Environment.NewLine"/>. 16public static readonly HtmlString NewLine = new HtmlString(Environment.NewLine);

Microsoft.AspNetCore.Http (1)

parent\parent\WebUtilities\src\AspNetCoreTempDirectory.cs (1)

19var temp = Environment.GetEnvironmentVariable("ASPNETCORE_TEMP") ?? // ASPNETCORE_TEMP - User set temporary location.

Microsoft.AspNetCore.Http.Connections (4)

Internal\HttpConnectionContext.cs (3)

90LastSeenTicks = TimeSpan.FromMilliseconds(Environment.TickCount64); 991LastSeenTicks = TimeSpan.FromMilliseconds(Environment.TickCount64); 1023_startedSendTime = TimeSpan.FromMilliseconds(Environment.TickCount64);

Internal\HttpConnectionManager.cs (1)

144var ticks = TimeSpan.FromMilliseconds(Environment.TickCount64);

Microsoft.AspNetCore.HttpLogging (3)

HttpLog.cs (2)

45builder.Append(Environment.NewLine); 53builder.Append(Environment.NewLine);

W3CLoggingMiddleware.cs (1)

94_serverName ??= Environment.MachineName;

Microsoft.AspNetCore.Identity.UI (4)

Generated\1\0\_Layout_cshtml.g_2.cs (2)

295$"we have looked at it in the following locations: {System.Environment.NewLine}{string.Join(System.Environment.NewLine, result.SearchedLocations)}.");

Generated\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\0\_Layout_cshtml.g.cs (2)

292$"we have looked at it in the following locations: {System.Environment.NewLine}{string.Join(System.Environment.NewLine, result.SearchedLocations)}.");

Microsoft.AspNetCore.InternalTesting (16)

AssemblyTestLog.cs (2)

41var maxPathString = Environment.GetEnvironmentVariable(MaxPathLengthEnvironmentVariableName); 226var stackTrace = Environment.StackTrace;

CultureReplacer.cs (2)

34_threadId = Environment.CurrentManagedThreadId; 73Assert.True(Environment.CurrentManagedThreadId == _threadId,

HelixHelper.cs (2)

13public static string GetTargetHelixQueue() => Environment.GetEnvironmentVariable("helix") ?? ""; 18var uploadRoot = Environment.GetEnvironmentVariable("HELIX_WORKITEM_UPLOAD_ROOT");

Logging\XunitLoggerProvider.cs (3)

47private static readonly string[] NewLineChars = new[] { Environment.NewLine }; 98if (message.EndsWith(Environment.NewLine, StringComparison.Ordinal)) 100message = message.Substring(0, message.Length - Environment.NewLine.Length);

Tracing\EventSourceValidator.cs (2)

103Environment.NewLine + string.Join(Environment.NewLine, errors));

xunit\AspNetTestRunner.cs (1)

102return new(totalTimeTaken, string.Join(Environment.NewLine, messages));

xunit\EnvironmentVariableSkipConditionAttribute.cs (1)

83return Environment.GetEnvironmentVariable(name);

xunit\MaximumOSVersionAttribute.cs (1)

74return Environment.OSVersion.Version;

xunit\MinimumOsVersionAttribute.cs (1)

70return Environment.OSVersion.Version;

xunit\SkipOnCIAttribute.cs (1)

41public static string GetIfOnAzdo() => Environment.GetEnvironmentVariable("AGENT_OS");

Microsoft.AspNetCore.Mvc.Core (20)

ApiConventionTypeAttribute.cs (3)

75Environment.NewLine + string.Join(Environment.NewLine, unsupportedAttributes) + Environment.NewLine,

ApplicationModels\ApplicationModelFactory.cs (9)

166Environment.NewLine, 213Environment.NewLine, 245var message = Resources.FormatAttributeRoute_DuplicateNames(routeName, Environment.NewLine, string.Join(Environment.NewLine, descriptions)); 333Environment.NewLine, 334string.Join(Environment.NewLine, actionDescriptions)); 342Environment.NewLine, 343string.Join(Environment.NewLine + Environment.NewLine, errorMessages));

ApplicationModels\InferParameterBindingInfoConvention.cs (2)

95var parameters = string.Join(Environment.NewLine, fromBodyParameters.Select(p => p.DisplayName)); 102message += Environment.NewLine + parameters;

Infrastructure\ActionSelector.cs (2)

99Environment.NewLine, 104Environment.NewLine,

Routing\AttributeRoute.cs (4)

164Environment.NewLine + Environment.NewLine, 168Environment.NewLine, 171var message = Resources.FormatAttributeRoute_AggregateErrorMessage(Environment.NewLine, allErrors);

Microsoft.AspNetCore.Mvc.Razor (6)

ApplicationParts\RazorCompiledItemFeatureProvider.cs (2)

28var viewsDifferingInCase = string.Join(Environment.NewLine, duplicates.Select(d => d.Identifier)); 31Environment.NewLine,

RazorView.cs (4)

285locations = Environment.NewLine + string.Join(Environment.NewLine, originalLocations); 291Environment.NewLine + string.Join(Environment.NewLine, layoutPageResult.SearchedLocations);

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

CompilationFailedException.cs (2)

24return Resources.CompilationFailed + Environment.NewLine + 26Environment.NewLine,

Microsoft.AspNetCore.Mvc.RazorPages (1)

Infrastructure\DefaultPageHandlerMethodSelector.cs (1)

52throw new InvalidOperationException(Resources.FormatAmbiguousHandler(Environment.NewLine, ambiguousMethods));

Microsoft.AspNetCore.Mvc.TagHelpers (9)

AnchorTagHelper.cs (1)

209Environment.NewLine,

FormActionTagHelper.cs (1)

221Environment.NewLine,

FormTagHelper.cs (1)

228Environment.NewLine,

PartialTagHelper.cs (5)

128var locations = Environment.NewLine + string.Join(Environment.NewLine, viewSearchedLocations); 133locations = Environment.NewLine + string.Join(Environment.NewLine, result.SearchedLocations); 134errorMessage += Environment.NewLine + Resources.FormatViewEngine_FallbackViewNotFound(FallbackName, locations);

ScriptTagHelper.cs (1)

372builder.AppendHtml(Environment.NewLine)

Microsoft.AspNetCore.Mvc.Testing (1)

src\095dea4ec402cc66\HostFactoryResolver.cs (1)

33if (uint.TryParse(Environment.GetEnvironmentVariable(TimeoutEnvironmentKey), out uint timeoutInSeconds))

Microsoft.AspNetCore.Mvc.ViewFeatures (11)

Filters\SaveTempDataPropertyFilterBase.cs (1)

114throw new InvalidOperationException(string.Join(Environment.NewLine, errorMessages));

HtmlHelper.cs (4)

527locations = Environment.NewLine + string.Join(Environment.NewLine, originalLocations); 533Environment.NewLine + string.Join(Environment.NewLine, viewEngineResult.SearchedLocations);

ViewComponents\DefaultViewComponentSelector.cs (2)

100var typeNames = string.Join(Environment.NewLine, matchedTypes); 102Resources.FormatViewComponent_AmbiguousTypeMatch(name, Environment.NewLine, typeNames));

ViewEngines\ViewEngineResult.cs (4)

98locations = Environment.NewLine + string.Join(Environment.NewLine, originalLocations); 103locations += Environment.NewLine + string.Join(Environment.NewLine, SearchedLocations);

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

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

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

153=> ThrowHelper.ThrowInvalidOperationException(message + Environment.NewLine + SR.FormatFile_0_Line_1(path, line)); 158=> ThrowHelper.ThrowInvalidOperationException<T>(message + Environment.NewLine + SR.FormatFile_0_Line_1(path, line));

Microsoft.AspNetCore.Routing (7)

EndpointMiddleware.cs (3)

107Environment.NewLine + 115Environment.NewLine + 123Environment.NewLine +

Matching\CandidateSet.cs (2)

350$"The following endpoints were found with the same priority:" + Environment.NewLine + 351string.Join(Environment.NewLine, duplicates.Select(e => e.DisplayName));

Matching\DefaultEndpointSelector.cs (2)

122Environment.NewLine, 123string.Join(Environment.NewLine, matches.Select(e => e.DisplayName)));

Microsoft.AspNetCore.Server.HttpSys (5)

HttpSysOptions.cs (2)

19internal static readonly int DefaultMaxAccepts = 5 * Environment.ProcessorCount; 75/// The default is 5 times the number of processors as returned by <see cref="Environment.ProcessorCount" />.

NativeInterop\SafeNativeOverlapped.cs (1)

14private static bool HasShutdownStarted => Environment.HasShutdownStarted

NativeInterop\UrlGroup.cs (2)

196throw new HttpSysException((int)statusCode, Resources.FormatException_AccessDenied(uriPrefix, Environment.UserDomainName + @"\" + Environment.UserName));

Microsoft.AspNetCore.Server.IIS (4)

src\aspnetcore\src\Shared\RazorViews\BaseView.cs (1)

283return string.Join(" " + Environment.NewLine,

StartupHook.cs (3)

28var detailedErrors = Environment.GetEnvironmentVariable("ASPNETCORE_DETAILEDERRORS"); 32var aspnetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"); 35var dotnetEnvironment = Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT");

Microsoft.AspNetCore.Server.IISIntegration (6)

WebHostBuilderIISExtensions.cs (6)

41var port = hostBuilder.GetSetting(ServerPort) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{ServerPort}"); 42var path = hostBuilder.GetSetting(ServerPath) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{ServerPath}"); 43var pairingToken = hostBuilder.GetSetting(PairingToken) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{PairingToken}"); 44var iisAuth = hostBuilder.GetSetting(IISAuth) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{IISAuth}"); 45var websocketsSupported = hostBuilder.GetSetting(IISWebSockets) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{IISWebSockets}"); 51isWebSocketsSupported = (Environment.OSVersion.Version >= new Version(6, 2));

Microsoft.AspNetCore.Server.IntegrationTesting (21)

Common\DotNetCommands.cs (5)

18var dotnetHome = Environment.GetEnvironmentVariable("DOTNET_HOME"); 20var dotnetRoot = Environment.GetEnvironmentVariable("DOTNET_ROOT"); 22var dotnetInstallDir = Environment.GetEnvironmentVariable("DOTNET_INSTALL_DIR"); 24var userProfile = Environment.GetEnvironmentVariable("USERPROFILE"); 25var home = Environment.GetEnvironmentVariable("HOME");

Deployers\NginxDeployer.cs (6)

103var retVal = Environment.GetEnvironmentVariable("LOGNAME") 104?? Environment.GetEnvironmentVariable("USER") 105?? Environment.GetEnvironmentVariable("USERNAME"); 153Logger.LogTrace($"Config File Content:{Environment.NewLine}===START CONFIG==={Environment.NewLine}{{configContent}}{Environment.NewLine}===END CONFIG===", DeploymentParameters.ServerConfigTemplateContent);

Deployers\RemoteWindowsDeployer\RemoteWindowsDeployer.cs (3)

183Logger.LogTrace($"Config File Content:{Environment.NewLine}===START CONFIG==={Environment.NewLine}{{configContent}}{Environment.NewLine}===END CONFIG===", webConfig.ToString());

src\aspnetcore\src\Shared\Process\ProcessEx.cs (4)

124if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("helix"))) 126startInfo.EnvironmentVariables["NUGET_FALLBACK_PACKAGES"] = Environment.GetEnvironmentVariable("NUGET_FALLBACK_PACKAGES"); 228private static string GetNugetPackagesRestorePath() => (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("NUGET_RESTORE"))) 233: Environment.GetEnvironmentVariable("NUGET_RESTORE");

xunit\IISExpressAncmSchema.cs (2)

22Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),

xunit\SkipIfEnvironmentVariableNotEnabled.cs (1)

26return string.Equals(Environment.GetEnvironmentVariable(_environmentVariableName), "true", StringComparison.OrdinalIgnoreCase);

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

Middleware\HttpsConnectionMiddleware.cs (2)

554if (Environment.OSVersion.Version < new Version(6, 3) // Missing ALPN support 556|| (Environment.OSVersion.Version < new Version(10, 0) && !enableHttp2OnWindows81))

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

1042return string.Join(Environment.NewLine, description);

src\aspnetcore\src\Shared\CertificateGeneration\MacOSCertificateManager.cs (4)

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

Systemd\KestrelServerOptionsSystemdExtensions.cs (3)

39if (string.Equals(Environment.ProcessId.ToString(CultureInfo.InvariantCulture), Environment.GetEnvironmentVariable(ListenPidEnvVar), StringComparison.Ordinal)) 42if (int.TryParse(Environment.GetEnvironmentVariable(ListenFdsEnvVar), NumberStyles.None, NumberFormatInfo.InvariantInfo, out var listenFds)

TlsConfigurationLoader.cs (3)

190var appData = Environment.GetEnvironmentVariable("APPDATA"); 191var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Microsoft.AspNetCore.Server.Kestrel.Transport.DirectTls (6)

DirectTlsTransportOptions.cs (3)

25/// Defaults to a value derived from <see cref="Environment.ProcessorCount"/> (see <see cref="DefaultWorkerCount"/>). 30/// The default <see cref="WorkerCount"/>, derived from <see cref="Environment.ProcessorCount"/>. 44var processorCount = Environment.ProcessorCount;

TlsEventPump.cs (2)

473SweepExpiredHandshakes(Environment.TickCount64); 748HandshakeDeadlineTimestamp = ComputeHandshakeDeadline(Environment.TickCount64),

TlsEventPumpPool.cs (1)

31pumpCount = pumpCount > 0 ? pumpCount : Environment.ProcessorCount;

Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes (2)

NamedPipeTransportOptions.cs (2)

19/// Defaults to <see cref="Environment.ProcessorCount" /> rounded down and clamped between 1 and 16. 21public int ListenerQueueCount { get; set; } = Math.Min(Environment.ProcessorCount, 16);

Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets (3)

Internal\IOQueue.cs (1)

88int processorCount = Environment.ProcessorCount;

SocketConnectionFactoryOptions.cs (1)

37/// Defaults to a value based on and limited to <see cref="Environment.ProcessorCount" />.

SocketTransportOptions.cs (1)

31/// Defaults to a value based on and limited to <see cref="Environment.ProcessorCount" />.

Microsoft.AspNetCore.SignalR.StackExchangeRedis (3)

Internal\AckHandler.cs (2)

51var currentTick = Environment.TickCount64; 91CreatedTick = Environment.TickCount64;

RedisHubLifetimeManager.cs (1)

814return $"{Environment.MachineName}_{Guid.NewGuid():N}";

Microsoft.AspNetCore.SpaProxy (3)

SpaProxyLaunchManager.cs (3)

223$processId = Get-Process -PID {Environment.ProcessId} -ErrorAction Stop; 286ps {Environment.ProcessId}; 290ps {Environment.ProcessId} > /dev/null;

Microsoft.AspNetCore.SpaServices.Extensions (1)

Npm\NodeScriptRunner.cs (1)

138+ $" Current PATH environment variable is: { Environment.GetEnvironmentVariable("PATH") }\n"

Microsoft.AspNetCore.TestHost (1)

src\095dea4ec402cc66\HostFactoryResolver.cs (1)

33if (uint.TryParse(Environment.GetEnvironmentVariable(TimeoutEnvironmentKey), out uint timeoutInSeconds))

Microsoft.AspNetCore.Watch.BrowserRefresh (4)

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

36=> Environment.GetEnvironmentVariable(name) is { Length: > 0 } value ? value : null;

src\sdk\src\Dotnet.Watch\Web.Middleware\BrowserScriptMiddleware.cs (2)

61var endpoint = Environment.GetEnvironmentVariable("ASPNETCORE_AUTO_RELOAD_WS_ENDPOINT")!; 62var serverKey = Environment.GetEnvironmentVariable("ASPNETCORE_AUTO_RELOAD_WS_KEY") ?? string.Empty;

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

14Environment.SetEnvironmentVariable("__ASPNETCORE_BROWSER_TOOLS", "true");

Microsoft.AspNetCore.WebUtilities (1)

AspNetCoreTempDirectory.cs (1)

19var temp = Environment.GetEnvironmentVariable("ASPNETCORE_TEMP") ?? // ASPNETCORE_TEMP - User set temporary location.

Microsoft.Build (131)

BackEnd\BuildManager\BuildManager.cs (2)

888switch (Environment.GetEnvironmentVariable("MSBuildDebugBuildManagerOnStart")) 2552if (Environment.GetEnvironmentVariable("MSBUILDCLEARXMLCACHEONBUILDMANAGER") == "1")

BackEnd\BuildManager\BuildParameters.cs (4)

65private static string s_startupDirectory = Environment.CurrentDirectory; 454set => _enableNodeReuse = Environment.GetEnvironmentVariable("MSBUILDDISABLENODEREUSE") == "1" ? false : value; 1048if (Environment.GetEnvironmentVariable("MSBUILDDISABLENODEREUSE") == "1") // For example to disable node reuse within Visual Studio 1053if (Environment.GetEnvironmentVariable("MSBUILDDETAILEDSUMMARY") == "1") // For example to get detailed summary within Visual Studio

BackEnd\BuildManager\CoordinatorClient.cs (1)

99=> Guid.TryParse(Environment.GetEnvironmentVariable(Constants.GrantIdEnvVarName), out grantId);

BackEnd\BuildManager\EnvironmentVariableValidator.cs (1)

35string? dotnetHostPath = Environment.GetEnvironmentVariable(Constants.DotnetHostPathEnvVarName);

BackEnd\Client\MSBuildClient.cs (2)

591bool enableServerGC = _multiThreaded && Environment.GetEnvironmentVariable("DOTNET_gcServer") is null; 635foreach (DictionaryEntry envVar in Environment.GetEnvironmentVariables())

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

1507file.WriteLine("{0}({1})-{2}: {3}", Thread.CurrentThread.Name, Environment.CurrentManagedThreadId, DateTime.UtcNow.Ticks, message);

BackEnd\Components\Caching\ConfigCache.cs (4)

39if (!int.TryParse(Environment.GetEnvironmentVariable("MSBUILDCONFIGCACHESWEEPTHRESHHOLD"), out _sweepThreshhold)) 246if (String.IsNullOrEmpty(Environment.GetEnvironmentVariable("MSBUILDENABLEAGGRESSIVECACHING"))) 383capacity => new ConcurrentDictionary<int, BuildRequestConfiguration>(Environment.ProcessorCount, capacity)); 388_byMetadata = new ConcurrentDictionary<ConfigurationMetadata, BuildRequestConfiguration>(Environment.ProcessorCount, configurationsById.Count);

BackEnd\Components\Communications\NodeLauncher.cs (5)

66bool showNodeWindow = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("MSBUILDNODEWINDOW")); 144$"Failed to launch node from {nodeLaunchData.MSBuildLocation}. CommandLine: {commandLineArgs}{Environment.NewLine}{ex}"); 328string useMSBuildServerEnvVarValue = Environment.GetEnvironmentVariable(Traits.UseMSBuildServerEnvVarName); 333Environment.SetEnvironmentVariable(Traits.UseMSBuildServerEnvVarName, "0"); 341Environment.SetEnvironmentVariable(Traits.UseMSBuildServerEnvVarName, useMSBuildServerEnvVarValue);

BackEnd\Components\Communications\NodeProviderInProc.cs (2)

130concurrencyLevel: Environment.ProcessorCount, 222if (Environment.GetEnvironmentVariable("MSBUILDINPROCENVCHECK") == "1")

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

256string msbuildExeName = Environment.GetEnvironmentVariable("MSBUILD_EXE_NAME");

BackEnd\Components\Communications\NodeProviderOutOfProcTaskHost.cs (3)

182name = Environment.GetEnvironmentVariable("MSBUILDTASKHOST_EXE_NAME") ?? "MSBuildTaskHost.exe"; 619name = Environment.GetEnvironmentVariable("MSBUILD_EXE_NAME"); 801string envPath = Environment.GetEnvironmentVariable(environmentVariable);

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

330string queueCapacityEnvironment = Environment.GetEnvironmentVariable("MSBUILDLOGGINGQUEUECAPACITY");

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

236message += Environment.NewLine + exception.ToString(); 271message += Environment.NewLine + exception.ToString();

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

37private static readonly ParallelOptions s_parallelOptions = new() { MaxDegreeOfParallelism = Environment.ProcessorCount };

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

692if (Environment.GetEnvironmentVariable("MSBUILDFORCESTA") == "1")

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

1255private static readonly bool s_sortInputsOutputs = (Environment.GetEnvironmentVariable("MSBUILDSORTINPUTSOUTPUTS") == "1");

BackEnd\Components\RequestBuilder\TaskBuilder.cs (2)

846if (ExceptionHandling.IsCriticalException(ex) || Environment.GetEnvironmentVariable("MSBUILDDONOTCATCHTASKEXCEPTIONS") == "1") 937if (ExceptionHandling.IsCriticalException(taskException) || (Environment.GetEnvironmentVariable("MSBUILDDONOTCATCHTASKEXCEPTIONS") == "1"))

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

46private static readonly bool s_breakOnLogAfterTaskReturns = Environment.GetEnvironmentVariable("MSBUILDBREAKONLOGAFTERTASKRETURNS") == "1"; 361_yieldThreadId = Environment.CurrentManagedThreadId; 390Assumed.Equal(_yieldThreadId, Environment.CurrentManagedThreadId, $"Cannot call Reacquire() on thread {Environment.CurrentManagedThreadId} when Yield() was called on thread {_yieldThreadId}");

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

227_schedulingUnlimitedVariable = Environment.GetEnvironmentVariable("MSBUILDSCHEDULINGUNLIMITED"); 238string strNodeLimitOffset = Environment.GetEnvironmentVariable("MSBUILDNODELIMITOFFSET"); 253if (!int.TryParse(Environment.GetEnvironmentVariable("MSBUILDCORELIMIT"), out _coreLimit) || _coreLimit <= 0) 260if (!int.TryParse(Environment.GetEnvironmentVariable("MSBUILDNODECOREALLOCATIONWEIGHT"), out _nodeCoreAllocationWeight) 915string customScheduler = Environment.GetEnvironmentVariable("MSBUILDCUSTOMSCHEDULER"); 960string multiplier = Environment.GetEnvironmentVariable("MSBUILDCUSTOMSCHEDULERFORSQLCONFIGURATIONLIMITMULTIPLIER"); 2712file.Write("{0}({1})-{2}: ", Thread.CurrentThread.Name, Environment.CurrentManagedThreadId, _schedulingData.EventTime.Ticks);

BackEnd\Components\SdkResolution\SdkResolverLoader.cs (3)

26private readonly string IncludeDefaultResolver = Environment.GetEnvironmentVariable("MSBUILDINCLUDEDEFAULTSDKRESOLVER"); 30private readonly string AdditionalResolversFolder = Environment.GetEnvironmentVariable( 36?? Environment.GetEnvironmentVariable("MSBUILDADDITIONALSDKRESOLVERSFOLDER");

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

254loggingContext.LogError(new BuildEventFileInfo(sdkReferenceLocation), "SingleResolverFailedToResolveSDK", sdk.Name, resolvers[0].Name, string.Join(Environment.NewLine, errors)); 259loggingContext.LogError(new BuildEventFileInfo(sdkReferenceLocation), "FailedToResolveSDK", sdk.Name, string.Join($"{Environment.NewLine} ", errors)); 397string resultWarnings = result.Warnings?.Any() == true ? string.Join(Environment.NewLine, result.Warnings) : "null"; 398string resultErrors = result.Errors?.Any() == true ? string.Join(Environment.NewLine, result.Errors) : "null";

BackEnd\Node\InProcNode.cs (2)

148_savedCurrentDirectory = Environment.CurrentDirectory; 482_savedCurrentDirectory = Environment.CurrentDirectory;

BackEnd\Node\OutOfProcNode.cs (5)

580if (Environment.GetEnvironmentVariable("MSBUILDCLEARXMLCACHEONCHILDNODES") == "1") 754Environment.SetEnvironmentVariable(key, null); 761Environment.SetEnvironmentVariable(environmentPair.Key, environmentPair.Value); 846string forwardPropertiesFromChild = Environment.GetEnvironmentVariable("MSBUILDFORWARDPROPERTIESFROMCHILD"); 858string forwardAllProperties = Environment.GetEnvironmentVariable("MSBUILDFORWARDALLPROPERTIESFROMCHILD");

BackEnd\TaskExecutionHost\TaskExecutionHost.cs (1)

1356Environment.NewLine + e.InnerException);

BuildCheck\Checks\UntrustedLocationCheck.cs (3)

97string? locationFromEnv = Environment.GetEnvironmentVariable("XDG_DOWNLOAD_DIR"); 104return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Downloads");

BuildCheck\Infrastructure\BuildCheckBuildEventHandler.cs (4)

200checkContext.DispatchAsCommentFromText(MessageImportance.Low, $"BuildCheck run times{Environment.NewLine}"); 209=> title + Environment.NewLine + String.Join(Environment.NewLine, rowData.Select(a => $"{a.Key},{a.Value}")) + Environment.NewLine;

Construction\ProjectElementContainer.cs (2)

577var leadingWhitespaceNode = XmlDocument.CreateWhitespace(Environment.NewLine + parentIndentation + DEFAULT_INDENT); 578var trailingWhiteSpaceNode = XmlDocument.CreateWhitespace(Environment.NewLine + parentIndentation);

Construction\ProjectRootElement.cs (3)

179_directory = Environment.CurrentDirectory; 204_directory = Environment.CurrentDirectory; 261_directory = Environment.CurrentDirectory;

Definition\Project.cs (1)

53private static readonly bool s_debugEvaluation = (Environment.GetEnvironmentVariable("MSBUILDDEBUGEVALUATION") != null);

ElementLocation\XmlDocumentWithLocation.cs (5)

364string windowsFolder = Environment.GetFolderPath(Environment.SpecialFolder.Windows); 386if (String.Equals(Environment.GetEnvironmentVariable("MSBuildLoadMicrosoftTargetsReadOnly"), "true", StringComparison.OrdinalIgnoreCase)) 391if (String.Equals(Environment.GetEnvironmentVariable("MSBUILDLOADALLFILESASREADONLY"), "1", StringComparison.OrdinalIgnoreCase)) 397if (String.Equals(Environment.GetEnvironmentVariable("MSBUILDLOADALLFILESASWRITEABLE"), "1", StringComparison.OrdinalIgnoreCase))

Evaluation\ConditionEvaluator.cs (1)

172private static readonly bool s_disableExpressionCaching = (Environment.GetEnvironmentVariable("MSBUILDDONOTCACHEEXPRESSIONS") == "1");

Evaluation\ItemSpec.cs (1)

585: Environment.CurrentDirectory;

Evaluation\ParserIgnoreConfiguration.cs (1)

201string? envValue = Environment.GetEnvironmentVariable(EnvironmentVariableName);

Evaluation\ProjectRootElementCache.cs (3)

75int.TryParse(Environment.GetEnvironmentVariable("MSBUILDPROJECTROOTELEMENTCACHESIZE"), out int cacheSize) ? cacheSize : 200; 80private static readonly bool s_debugLogCacheActivity = Environment.GetEnvironmentVariable("MSBUILDDEBUGXMLCACHE") == "1"; 88private static readonly bool s_сheckFileContent = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("MSBUILDCACHECHECKFILECONTENT"));

Instance\ProjectInstance.cs (3)

3122foreach (DictionaryEntry environmentVariable in Environment.GetEnvironmentVariables()) 3139Environment.SetEnvironmentVariable(environmentVariableName, null); 3152Environment.SetEnvironmentVariable(clearedVariable.Key as string, clearedVariable.Value as string);

Instance\TaskFactories\AssemblyTaskFactory.cs (2)

272ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, Environment.NewLine + e.InnerException.ToString()); 468ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, Environment.NewLine + e.InnerException.ToString());

Instance\TaskRegistry.cs (1)

1471ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskFactoryLoadFailure", TaskFactoryAttributeName, taskFactoryLoadInfo.AssemblyLocation, Environment.NewLine + e.InnerException.ToString());

Logging\BaseConsoleLogger.cs (2)

143WriteHandler(Environment.NewLine); 883Traits.LogAllEnvironmentVariables = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("MSBUILDLOGALLENVIRONMENTVARIABLES"));

Logging\BinaryLogger\BinaryLogger.cs (7)

349_initialIsBinaryLoggerEnabled = Environment.GetEnvironmentVariable("MSBUILDBINARYLOGGERENABLED"); 351Environment.SetEnvironmentVariable("MSBUILDTARGETOUTPUTLOGGING", "true"); 352Environment.SetEnvironmentVariable("MSBUILDLOGIMPORTS", "1"); 353Environment.SetEnvironmentVariable("MSBUILDBINARYLOGGERENABLED", bool.TrueString); 499Environment.SetEnvironmentVariable("MSBUILDTARGETOUTPUTLOGGING", _initialTargetOutputLogging ? "true" : null); 500Environment.SetEnvironmentVariable("MSBUILDLOGIMPORTS", _initialLogImports ? "1" : null); 501Environment.SetEnvironmentVariable("MSBUILDBINARYLOGGERENABLED", _initialIsBinaryLoggerEnabled);

Logging\BinaryLogger\BuildEventArgsReader.cs (1)

1892if (!Environment.Is64BitProcess)

Logging\OptimizedStringIndenter.cs (3)

64int indentedStringLength = segments.Length * (Environment.NewLine.Length + indent); 86Environment.NewLine.CopyTo(output); 87output = output.Slice(Environment.NewLine.Length);

Logging\ParallelLogger\ConsoleOutputAligner.cs (1)

59int estimatedCapacity = message.Length + ((prefixAlreadyWritten ? 0 : prefixWidth) + Environment.NewLine.Length) * (message.Length / averageLineLength + 1);

Logging\TerminalLogger\TerminalLogger.cs (2)

126private readonly string _initialWorkingDirectory = Environment.CurrentDirectory; 291string tlEnvVariable = Environment.GetEnvironmentVariable("MSBUILDTERMINALLOGGER") ?? string.Empty;

parent\Shared\LogMessagePacketBase.cs (2)

269private static readonly int s_defaultPacketVersion = (Environment.Version.Major * 10) + Environment.Version.Minor;

parent\Shared\TaskLoggingHelper.cs (3)

1278message += Environment.NewLine + exception.StackTrace; 1643bool diagnostics = Environment.GetEnvironmentVariable("MSBUILDDIAGNOSTICS") != null; 1650message += Environment.NewLine + exception.StackTrace;

parent\Shared\Tracing.cs (1)

120Trace.WriteLine(System.Environment.StackTrace);

Resources\Constants.cs (2)

247[DynamicDependency(PropertyFunctionMembers, typeof(Environment))] 316var environmentType = new Tuple<string, Type>(null, typeof(Environment));

src\msbuild\artifacts\.packages\microsoft.codeanalysis.pooledobjects\5.0.0-1.25277.114\contentFiles\cs\netstandard2.0\ObjectPool`1.cs (1)

112: this(factory, Environment.ProcessorCount * 2, trimOnFree)

src\msbuild\src\Shared\Debugging\DebugUtils.cs (3)

178builder.Append(Environment.NewLine); 181builder.Append(Environment.NewLine); 183builder.Append(Environment.NewLine);

Utilities\EngineFileUtilities.cs (1)

572string? wildCards = Environment.GetEnvironmentVariable("MsBuildSkipEagerWildCardEvaluationRegexes");

Utilities\Utilities.cs (12)

Microsoft.Build.Framework (130)

BackEnd\CommunicationsUtilities.cs (5)

238/// Sets an environment variable using <see cref="Environment.SetEnvironmentVariable(string,string)" />. 241=> Environment.SetEnvironmentVariable(name, value); 265IDictionary vars = Environment.GetEnvironmentVariables(); 820? $"TID {Environment.CurrentManagedThreadId}" 821: $"{threadName} (TID {Environment.CurrentManagedThreadId})";

BackEnd\Handshake.cs (1)

93string handshakeSalt = Environment.GetEnvironmentVariable("MSBUILDNODEHANDSHAKESALT") ?? "";

BuildEnvironmentHelper.cs (2)

486return Environment.GetEnvironmentVariable(variable); 729return Environment.GetEnvironmentVariable("MSBuildSDKsPath") ?? defaultSdkPath;

BuildEnvironmentState.cs (3)

32string? msbuildHostName = Environment.GetEnvironmentVariable("MSBUILD_HOST_NAME"); 38if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("VSCODE_CWD")) 39|| string.Equals(Environment.GetEnvironmentVariable("TERM_PROGRAM"), "vscode", StringComparison.OrdinalIgnoreCase))

ChangeWaves.cs (1)

136string msbuildDisableFeaturesFromVersion = Environment.GetEnvironmentVariable("MSBUILDDISABLEFEATURESFROMVERSION");

Coordinator\CoordinatorSettings.cs (4)

65get => _totalNodeBudget ??= Environment.ProcessorCount; 66init => _totalNodeBudget = value <= 0 ? Environment.ProcessorCount : value; 113string? pipeNameOverride = Environment.GetEnvironmentVariable(Constants.PipeNameEnvVarName); 127Environment.ProcessorCount),

DebugTrace.cs (1)

19private static readonly bool s_enabled = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("MSBUILDENABLEDEBUGTRACING"));

DebugUtils.cs (5)

68string environmentDebugPath = FileUtilities.TrimAndStripAnyQuotes(Environment.GetEnvironmentVariable("MSBUILDDEBUGPATH")); 89Environment.SetEnvironmentVariable("MSBUILDDEBUGPATH", debugDirectory); 102() => NodeModeHelper.ExtractFromCommandLine(Environment.CommandLine)); 106var processNameToBreakInto = Environment.GetEnvironmentVariable("MSBuildDebugProcessName"); 124private static string GetProcessInfoString() => $"{(ProcessNodeMode.Value?.ToString() ?? "CentralNode")}_{EnvironmentUtilities.ProcessName}_PID={EnvironmentUtilities.CurrentProcessId}_x{(Environment.Is64BitProcess ? "64" : "86")}";

DotnetHostEnvironmentHelper.cs (4)

53Environment.SetEnvironmentVariable(DotnetRootEnvVarName, null); 60Environment.SetEnvironmentVariable(varName, null); 74string? resolvedPath = dotnetHostPath ?? Environment.GetEnvironmentVariable(Constants.DotnetHostPathEnvVarName); 139dotnetHostPath ??= Environment.GetEnvironmentVariable(Constants.DotnetHostPathEnvVarName);

EncodingUtilities.cs (3)

303if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.OSVersion.Version.Major >= 10) // UTF-8 is only officially supported on 10+. 325return string.Equals(Environment.GetEnvironmentVariable("DOTNET_CLI_FORCE_UTF8_ENCODING"), "true", StringComparison.OrdinalIgnoreCase); 338string? dotnetCliLanguage = Environment.GetEnvironmentVariable("DOTNET_CLI_UI_LANGUAGE");

EnvironmentUtilities.cs (7)

30return Environment.ProcessId; 64return Environment.ProcessPath; 104/// Cached because <see cref="Environment.UserName"/> queries the OS and allocates on every call 107public static string CurrentUserName => field ??= Environment.UserName; 126string? value = Environment.GetEnvironmentVariable(name); 145string? value = Environment.GetEnvironmentVariable(name); 161string? value = Environment.GetEnvironmentVariable(name);

FeatureSwitches.cs (1)

76: Environment.GetEnvironmentVariable("MSBUILDENABLEALLPROPERTYFUNCTIONS") == "1";

FileClassifier.cs (1)

124string? programFiles = Environment.GetEnvironmentVariable(programFilesEnv);

FileUtilities_TempFiles.cs (1)

42if (string.Equals(Environment.GetEnvironmentVariable("MSBUILDPRESERVETOOLTEMPFILES"), "1", StringComparison.Ordinal))

FileUtilities.cs (3)

1078if (!int.TryParse(Environment.GetEnvironmentVariable("MSBUILDDIRECTORYDELETERETRYCOUNT"), out retryCount)) 1083if (!int.TryParse(Environment.GetEnvironmentVariable("MSBUILDDIRECTORYDELETRETRYTIMEOUT"), out retryTimeOut)) 1416return hasMaxPath && !IsRootedNoThrow(path) && Environment.CurrentDirectory.Length + path.Length + 1 /* slash */ >= maxPath;

InternalErrorException.cs (1)

115if (Environment.GetEnvironmentVariable("MSBUILDLAUNCHDEBUGGER") != null)

LazyFormattedBuildEventArgs.cs (1)

147argValue = $"Argument conversion to string failed{Environment.NewLine}{e}";

MSBuildConstants.cs (1)

131internal static readonly string[] EnvironmentNewLine = [Environment.NewLine];

MultiProcessTaskEnvironmentDriver.cs (2)

35get => new AbsolutePath(Environment.CurrentDirectory, ignoreRootedCheck: true); 48return Environment.GetEnvironmentVariable(name);

MultiThreadedTaskEnvironmentDriver.cs (1)

46IDictionary variables = Environment.GetEnvironmentVariables();

NativeMethods.cs (2)

197int numberOfCpus = Environment.ProcessorCount; 1278acceptAnsiColorCodes = AnsiDetector.IsAnsiSupported(Environment.GetEnvironmentVariable("TERM"));

src\msbuild\artifacts\.packages\microsoft.codeanalysis.contracts\5.0.0-1.25277.114\contentFiles\cs\net9.0\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 110Fail("ASSERT FAILED" + Environment.NewLine + message);

Traits.cs (68)

Utilities\FrameworkLocationHelper.cs (8)

140internal static readonly string programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); 841string complusInstallRoot = Environment.GetEnvironmentVariable("COMPLUS_INSTALLROOT"); 842string complusVersion = Environment.GetEnvironmentVariable("COMPLUS_VERSION"); 936string programFilesX86 = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86); 958programFilesX64 = Environment.GetEnvironmentVariable("ProgramW6432"); 976string combinedPath = Environment.GetEnvironmentVariable("ReferenceAssemblyRoot");

Utilities\ProcessExtensions.cs (1)

75string? value = Environment.GetEnvironmentVariable("MSBUILDPROCESSCOMMANDLINESOURCE");

Microsoft.Build.Tasks.CodeAnalysis (16)

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

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

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

241private static readonly string[] s_separator = { Environment.NewLine };

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

13extension(Environment)

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

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

146var threadId = Environment.CurrentManagedThreadId; 148string output = prefix + message + Environment.NewLine;

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

Microsoft.Build.Tasks.Core (61)

AssemblyDependency\Node\OutOfProcRarNode.cs (1)

22: this(Environment.ProcessorCount)

BootstrapperUtil\BootstrapperBuilder.cs (5)

35private static readonly bool s_logging = !String.IsNullOrEmpty(Environment.GetEnvironmentVariable("VSPLOG")); 522productsOrder.Append(p.ProductCode).Append(Environment.NewLine); 1984return str.Replace("%NEWLINE%", Environment.NewLine); 2209Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),

Exec.cs (1)

534return Environment.GetEnvironmentVariable("ComSpec");

GenerateApplicationManifest.cs (4)

230int t1 = Environment.TickCount; 249Util.WriteLog($"GenerateApplicationManifest.AddIsolatedComReferences t={Environment.TickCount - t1}"); 275int t1 = Environment.TickCount; 335Util.WriteLog($"GenerateApplicationManifest.AddClickOnceFiles t={Environment.TickCount - t1}");

GenerateManifestBase.cs (6)

446_startTime = Environment.TickCount; 534int t1 = Environment.TickCount; 544Util.WriteLog($"GenerateManifestBase.ResolveFiles t={Environment.TickCount - t1}"); 639int t1 = Environment.TickCount; 653Util.WriteLog($"GenerateManifestBase.WriteManifest t={Environment.TickCount - t1}"); 654Util.WriteLog($"Total time to generate manifest '{Path.GetFileName(OutputManifest.ItemSpec)}': t={Environment.TickCount - _startTime}");

ManifestUtil\ApplicationManifest.cs (4)

431int t1 = Environment.TickCount; 510Util.WriteLog($"GenerateManifest.CheckForComDuplicates t={Environment.TickCount - t1}"); 640int t1 = Environment.TickCount; 720Util.WriteLog($"GenerateManifest.CheckManifestReferences t={Environment.TickCount - t1}");

ManifestUtil\ManifestFormatter.cs (2)

16int t1 = Environment.TickCount; 98Util.WriteLog($"ManifestWriter.Format t={Environment.TickCount - t1}");

ManifestUtil\ManifestReader.cs (4)

188int t1 = Environment.TickCount; 230Util.WriteLog(String.Format(CultureInfo.InvariantCulture, "ManifestReader.ReadManifest t={0}", Environment.TickCount - t1)); 253int t1 = Environment.TickCount; 258Util.WriteLog($"ManifestReader.Deserialize t={Environment.TickCount - t1}");

ManifestUtil\ManifestWriter.cs (4)

31int t1 = Environment.TickCount; 33Util.WriteLog($"ManifestWriter.Serialize t={Environment.TickCount - t1}"); 107int t1 = Environment.TickCount; 203Util.WriteLog($"ManifestWriter.WriteManifest t={Environment.TickCount - t1}");

ManifestUtil\PathUtil.cs (1)

230$"{path.AsSpan(0, i)}{Environment.MachineName.ToLowerInvariant()}{path.AsSpan(i + localHost.Length)}" :

ManifestUtil\TrustInfo.cs (2)

708int t1 = Environment.TickCount; 798Util.WriteLog($"ManifestWriter.WriteTrustInfo t={Environment.TickCount - t1}");

ManifestUtil\Util.cs (5)

27internal static readonly string Schema = Environment.GetEnvironmentVariable("VSPSCHEMA"); 28internal static readonly bool logging = !String.IsNullOrEmpty(Environment.GetEnvironmentVariable("VSPLOG")); 116Version v = Environment.Version; 267string logPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"Microsoft\VisualStudio\8.0\VSPLOG");

ManifestUtil\XmlUtil.cs (10)

parent\Shared\AssemblyFolders\AssemblyFoldersEx.cs (1)

85bool is64bitOS = Environment.Is64BitOperatingSystem;

parent\Shared\AssemblyFolders\AssemblyFoldersFromConfig.cs (1)

43if (Environment.Is64BitOperatingSystem)

parent\Shared\LogMessagePacketBase.cs (2)

269private static readonly int s_defaultPacketVersion = (Environment.Version.Major * 10) + Environment.Version.Minor;

parent\Shared\Tracing.cs (1)

120Trace.WriteLine(System.Environment.StackTrace);

RoslynCodeTaskFactory\RoslynCodeTaskFactory.cs (3)

760bool deleteSourceCodeFile = Environment.GetEnvironmentVariable("MSBUILDLOGCODETASKFACTORYOUTPUT") == null; 783string toolExe = Environment.GetEnvironmentVariable("CscToolExe"); 799string toolExe = Environment.GetEnvironmentVariable("VbcToolExe");

RoslynCodeTaskFactory\RoslynCodeTaskFactoryCompilers.cs (1)

55_dotnetCliPath = Environment.GetEnvironmentVariable(Constants.DotnetHostPathEnvVarName);

src\msbuild\src\Shared\Debugging\DebugUtils.cs (3)

178builder.Append(Environment.NewLine); 181builder.Append(Environment.NewLine); 183builder.Append(Environment.NewLine);

Microsoft.Build.Tasks.Git (4)

GitDataReader\GitEnvironment.cs (4)

85return Environment.GetEnvironmentVariable(name); 96homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile, Environment.SpecialFolderOption.DoNotVerify);

Microsoft.Build.Utilities.Core (22)

AssemblyFolders\AssemblyFoldersFromConfigInfo.cs (1)

35DirectoryPath = Environment.ExpandEnvironmentVariables(directoryPath);

CommandLineBuilder.cs (1)

220CommandLine.Append(Environment.NewLine);

parent\Shared\AssemblyFolders\AssemblyFoldersEx.cs (1)

85bool is64bitOS = Environment.Is64BitOperatingSystem;

parent\Shared\AssemblyFolders\AssemblyFoldersFromConfig.cs (1)

43if (Environment.Is64BitOperatingSystem)

parent\Shared\TaskLoggingHelper.cs (3)

parent\Shared\Tracing.cs (1)

120Trace.WriteLine(System.Environment.StackTrace);

src\msbuild\src\Shared\Debugging\DebugUtils.cs (3)

178builder.Append(Environment.NewLine); 181builder.Append(Environment.NewLine); 183builder.Append(Environment.NewLine);

ToolLocationHelper.cs (9)

1626return Environment.GetFolderPath(Environment.SpecialFolder.System); 1829if (!Environment.Is64BitOperatingSystem || platformTarget.Equals("x86", StringComparison.OrdinalIgnoreCase) || platformTarget.Equals("arm", StringComparison.OrdinalIgnoreCase)) 2872bool is64bitOS = Environment.Is64BitOperatingSystem; 2900string userLocalAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); 2948string sdkDirectoryRootsFromEnvironment = Environment.GetEnvironmentVariable("MSBUILDSDKREFERENCEDIRECTORY"); 2975string sdkDirectoryRootsFromEnvironment = Environment.GetEnvironmentVariable("MSBUILDMULTIPLATFORMSDKREFERENCEDIRECTORY"); 2995string disableRegistryForSDKLookup = Environment.GetEnvironmentVariable("MSBUILDDISABLEREGISTRYFORSDKLOOKUP");

ToolTask.cs (2)

63private static readonly bool s_preserveTempFiles = string.Equals(Environment.GetEnvironmentVariable("MSBUILDPRESERVETOOLTEMPFILES"), "1", StringComparison.Ordinal); 1551$@"%SystemRoot%\System32\chcp.com {encoding.CodePage}>nul{Environment.NewLine}",

Microsoft.CodeAnalysis (30)

Collections\CachingFactory.cs (1)

200Environment.ProcessorCount * 2);

DiagnosticAnalyzer\AnalyzerDriver.cs (1)

337private readonly int _workerCount = Environment.ProcessorCount;

DiagnosticAnalyzer\AnalyzerExecutor.cs (3)

1387Environment.FailFast(CreateAnalyzerExceptionDiagnostic(analyzer, ex, info).ToString()); 1441var contextInformation = string.Join(Environment.NewLine, CreateDiagnosticDescription(info, e), CreateDisablingMessage(analyzer, analyzerName)).Trim(); 1454return string.Join(Environment.NewLine,

DiagnosticAnalyzer\ProgramFilesAnalyzerPathResolver.cs (2)

34var programFilesPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);

DiaSymReader\SymUnmanagedFactory.cs (1)

83foreach (var method in typeof(Environment).GetTypeInfo().GetDeclaredMethods("GetEnvironmentVariable"))

FileSystem\PathUtilities.cs (2)

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

InternalUtilities\Debug.cs (2)

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

InternalUtilities\EnvironmentExtensions.cs (1)

13extension(Environment)

InternalUtilities\NoMessagePumpSyncContext.cs (1)

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

InternalUtilities\RoslynParallel.cs (2)

15internal static readonly ParallelOptions DefaultParallelOptions = new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount }; 21? new ParallelOptions { CancellationToken = cancellationToken, MaxDegreeOfParallelism = Environment.ProcessorCount }

InternalUtilities\StringTable.cs (3)

InternalUtilities\TextKeyedCache.cs (1)

88Environment.ProcessorCount * 4);

Interop\ClrStrongName.cs (2)

39if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("COMPLUS_InstallRoot"))) 41var version = Environment.GetEnvironmentVariable("COMPLUS_Version");

RuleSet\RuleSetInclude.cs (1)

107includePath = Environment.ExpandEnvironmentVariables(includePath);

SourceGeneration\GeneratorDriver.cs (1)

453Environment.FailFast(CreateGeneratorExceptionDiagnostic(messageProvider, sourceGenerator, e, isInit).ToString());

src\roslyn\src\Compilers\Core\AnalyzerDriver\AnalyzerExceptionDescriptionBuilder.cs (2)

16private static readonly string s_separator = Environment.NewLine + "-----" + Environment.NewLine;

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

Microsoft.CodeAnalysis.Analyzers (27)

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

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (3)

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (5)

36/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 54/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 214/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 232/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 374private static int DefaultDegreeOfParallelism => Environment.ProcessorCount;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

173foreach (var line in child.ToString().Split([Environment.NewLine], StringSplitOptions.RemoveEmptyEntries))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingOptions2.cs (1)

47_ => Environment.NewLine

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\LineFormattingOptions.cs (1)

19[DataMember] public string NewLine { get; init; } = Environment.NewLine;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\RoslynTelemetry_LogBlock.cs (3)

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

285: reason + Environment.NewLine + restString;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\NonReentrantLock.cs (3)

Microsoft.CodeAnalysis.AnalyzerUtilities (27)

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

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (3)

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (5)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

173foreach (var line in child.ToString().Split([Environment.NewLine], StringSplitOptions.RemoveEmptyEntries))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingOptions2.cs (1)

47_ => Environment.NewLine

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\LineFormattingOptions.cs (1)

19[DataMember] public string NewLine { get; init; } = Environment.NewLine;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\RoslynTelemetry_LogBlock.cs (3)

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

285: reason + Environment.NewLine + restString;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\NonReentrantLock.cs (3)

Microsoft.CodeAnalysis.BuildClient.Package (13)

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

13extension(Environment)

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

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

146var threadId = Environment.CurrentManagedThreadId; 148string output = prefix + message + Environment.NewLine;

src\roslyn\src\Compilers\Shared\StandardBuildEnvironment.cs (3)

Microsoft.CodeAnalysis.CodeStyle (27)

src\roslyn\src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderHelper.cs (1)

122var eolLength = Environment.NewLine.Length;

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

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (3)

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingOptions2.cs (1)

47_ => Environment.NewLine

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\LineFormattingOptions.cs (1)

19[DataMember] public string NewLine { get; init; } = Environment.NewLine;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\RoslynTelemetry_LogBlock.cs (3)

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

285: reason + Environment.NewLine + restString;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\NonReentrantLock.cs (3)

Microsoft.CodeAnalysis.CSharp (3)

Binder\Binder.cs (1)

1003var lines = scope.ScopeDesignator.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

Utilities\EnvironmentExtensions.cs (2)

11extension(Environment) 18return Environment.ProcessId;

Microsoft.CodeAnalysis.CSharp.CodeStyle (1)

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

91var newLine = Environment.NewLine;

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

src\roslyn\src\Analyzers\CSharp\CodeFixes\DocumentationComments\CSharpAddDocCommentNodesCodeFixProvider.cs (2)

81return elementNode.WithTrailingTrivia(SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)); 85SyntaxFactory.ParseLeadingTrivia(Environment.NewLine)

Microsoft.CodeAnalysis.CSharp.Features (5)

Completion\CompletionProviders\SnippetCompletionProvider.cs (1)

189description: (snippet.Title + Environment.NewLine + snippet.Description).ToSymbolDisplayParts(),

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (1)

592[EndOfLine(Environment.NewLine)]),

Snippets\CSharpSnippetFunctionService.cs (1)

54var str = "case " + fullyQualifiedTypeName + "." + firstEnumMemberName + ":" + Environment.NewLine + " break;";

src\roslyn\src\Analyzers\CSharp\CodeFixes\DocumentationComments\CSharpAddDocCommentNodesCodeFixProvider.cs (2)

81return elementNode.WithTrailingTrivia(SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)); 85SyntaxFactory.ParseLeadingTrivia(Environment.NewLine)

Microsoft.CodeAnalysis.CSharp.NetAnalyzers (1)

Microsoft.NetCore.Analyzers\Runtime\CSharpPreferReadOnlySpanPropertiesOverReadOnlyArrayFields.Fixer.cs (1)

583return Environment.NewLine;

Microsoft.CodeAnalysis.CSharp.Workspaces (3)

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

91var newLine = Environment.NewLine;

SyncedSource\FileBasedPrograms\VirtualProjectBuilder.cs (2)

158: Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

Microsoft.CodeAnalysis.Extensions.Package (4)

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

Microsoft.CodeAnalysis.ExternalAccess.OmniSharp (1)

Options\OmniSharpLineFormattingOptions.cs (1)

14public string NewLine { get; init; } = Environment.NewLine;

Microsoft.CodeAnalysis.Features (15)

Completion\CommonCompletionProvider.cs (1)

92parts = parts.Add(new TaggedText(TextTags.LineBreak, Environment.NewLine));

Completion\Providers\Snippets\AbstractSnippetCompletionProvider.cs (1)

95description: (snippetData.Description + Environment.NewLine + string.Format(FeaturesResources.Code_snippet_for_0, snippetData.Description)).ToSymbolDisplayParts(),

Diagnostics\Service\DiagnosticAnalyzerService_ComputeDiagnosticAnalysisResults.cs (1)

51=> $"project: ({project.Id}), ({string.Join(Environment.NewLine, analyzers.Select(a => a.ToString()))})";

EditAndContinue\EditAndContinueService.cs (2)

47=> byte.TryParse(Environment.GetEnvironmentVariable("Microsoft_CodeAnalysis_EditAndContinue_DiagnosticLevel"), out var level) 80var path = Environment.GetEnvironmentVariable("Microsoft_CodeAnalysis_EditAndContinue_LogDir");

ExternalAccess\UnitTesting\Notification\AbstractGlobalOperationNotificationService.cs (1)

41if (!Environment.HasShutdownStarted)

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingLowPriorityProcessor.cs (1)

102Logger.Log(FunctionId.WorkCoordinator_Project_Enqueue, s_enqueueLogger, Environment.TickCount, item.ProjectId, !added);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingNormalPriorityProcessor.cs (1)

69Logger.Log(FunctionId.WorkCoordinator_DocumentWorker_Enqueue, s_enqueueLogger, Environment.TickCount, item.DocumentId, !added);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingSemanticChangeProcessor.cs (2)

263Logger.Log(FunctionId.WorkCoordinator_SemanticChange_Enqueue, s_enqueueLogger, Environment.TickCount, documentId, changedMember != null); 379Logger.Log(FunctionId.WorkCoordinator_Project_Enqueue, s_enqueueLogger, Environment.TickCount, projectId);

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

292var documentTooltip = navigateDocument.FilePath + Environment.NewLine + dllPath;

SemanticSearch\SearchExceptionDefinitionItem.cs (1)

27new TaggedText(TextTags.Space, Environment.NewLine),

src\roslyn\src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderHelper.cs (1)

122var eolLength = Environment.NewLine.Length;

src\roslyn\src\Compilers\Core\AnalyzerDriver\AnalyzerExceptionDescriptionBuilder.cs (2)

16private static readonly string s_separator = Environment.NewLine + "-----" + Environment.NewLine;

Microsoft.CodeAnalysis.Features.ExternalAccess (1)

Copilot\Internal\SemanticSearch\CopilotSemanticSearchQueryExecutor.cs (1)

48RuntimeException ??= $"{exception.TypeName.ToVisibleDisplayString(includeLeftToRightMarker: false)}: {exception.Message}{Environment.NewLine}{exception.StackTrace.ToVisibleDisplayString(includeLeftToRightMarker: false)}";

Microsoft.CodeAnalysis.NetAnalyzers (3)

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

231var indexOfNewLine = argument.IndexOf(Environment.NewLine, StringComparison.Ordinal);

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

172foreach (var line in child.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))

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

111: this(factory, Environment.ProcessorCount * 2)

Microsoft.CodeAnalysis.Razor.Compiler (13)

Language\Components\ComponentDiagnosticFactory.cs (6)

134Environment.NewLine + string.Join(Environment.NewLine, attributes.Select(p => p.TagHelper.DisplayName))); 146Environment.NewLine + string.Join(Environment.NewLine, attributes.Select(p => p.TagHelper.DisplayName))); 367Environment.NewLine + string.Join(Environment.NewLine, attributes.Select(p => p.TagHelper.DisplayName)));

Language\Extensions\EliminateMethodBodyPass.cs (3)

41IntermediateNodeFactory.CSharpToken("#pragma warning disable 0414" + Environment.NewLine), 44IntermediateNodeFactory.CSharpToken("#pragma warning disable 0649" + Environment.NewLine), 47IntermediateNodeFactory.CSharpToken("#pragma warning disable 0169" + Environment.NewLine)

Language\Legacy\SourceLocationTracker.cs (2)

37if ((Environment.NewLine.Length == 1 && characterRead == Environment.NewLine[0]) ||

Language\RazorCodeGenerationOptions.cs (1)

11private static string DefaultNewLine => Environment.NewLine;

Language\Syntax\SyntaxSerializer.cs (1)

210Builder.Append(value.Replace(Environment.NewLine, "LF"));

Microsoft.CodeAnalysis.ResxSourceGenerator (32)

AbstractResxGenerator.cs (5)

250var exceptionLines = ex.ToString().Split([Environment.NewLine], StringSplitOptions.None); 251var text = string.Join("", exceptionLines.Select(line => "#error " + line + Environment.NewLine)); 563{{string.Join(Environment.NewLine, getResourceStringAttributes.Select(attr => memberIndent + attr))}} 621namespaceStart = $@"namespace {namespaceName}{Environment.NewLine}{{"; 641var crLf = Environment.NewLine;

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

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (3)

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (5)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

173foreach (var line in child.ToString().Split([Environment.NewLine], StringSplitOptions.RemoveEmptyEntries))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingOptions2.cs (1)

47_ => Environment.NewLine

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\LineFormattingOptions.cs (1)

19[DataMember] public string NewLine { get; init; } = Environment.NewLine;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\RoslynTelemetry_LogBlock.cs (3)

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

285: reason + Environment.NewLine + restString;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\NonReentrantLock.cs (3)

Microsoft.CodeAnalysis.Scripting (2)

Hosting\ObjectFormatter\CommonObjectFormatter.cs (2)

43newLine: Environment.NewLine, 74builder.Append(Environment.NewLine);

Microsoft.CodeAnalysis.TestAnalyzerReference (1)

NonSourceFileRefactoring.cs (1)

28var newText = SourceText.From(text.ToString() + Environment.NewLine + "# Refactored");

Microsoft.CodeAnalysis.Workspaces (43)

Log\RoslynEventSource.LogBlock.cs (2)

72_tick = Environment.TickCount; 147var delta = Environment.TickCount - _tick;

Log\TraceEventSink.cs (3)

21=> Trace.WriteLine(string.Format("[{0}] {1} - {2}", Environment.CurrentManagedThreadId, functionId.ToString(), logMessage.GetMessage())); 24=> Trace.WriteLine(string.Format("[{0}] Start({1}) : {2} - {3}", Environment.CurrentManagedThreadId, uniquePairId, functionId.ToString(), logMessage.GetMessage())); 29Trace.WriteLine(string.Format("[{0}] End({1}) : [{2}ms] {3}", Environment.CurrentManagedThreadId, uniquePairId, delta, functionString));

Log\WorkspaceErrorLogger.cs (1)

25=> exception.Message + Environment.NewLine + exception.StackTrace;

Log\WorkspaceStructureLogger.cs (2)

222return ReplacePathComponent(s, Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "%USERPROFILE%");

Remote\IRemoteKeepAliveService.cs (1)

221if (Environment.HasShutdownStarted)

Shared\TestHooks\AsynchronousOperationListenerProvider.cs (2)

207var enabled = Environment.GetEnvironmentVariable("RoslynWaiterEnabled"); 228var enabled = Environment.GetEnvironmentVariable("RoslynWaiterDiagnosticTokenEnabled");

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

34var programFilesPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);

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

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (3)

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingOptions2.cs (1)

47_ => Environment.NewLine

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\LineFormattingOptions.cs (1)

19[DataMember] public string NewLine { get; init; } = Environment.NewLine;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\RoslynTelemetry_LogBlock.cs (3)

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

285: reason + Environment.NewLine + restString;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\NonReentrantLock.cs (3)

TemporaryStorage\TemporaryStorageService.Factory.cs (1)

35var forceSingleFile = !Environment.Is64BitProcess;

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

50var appDataFolder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData, Environment.SpecialFolderOption.Create);

Workspace\ProjectSystem\ReferenceFileChangeTracker.cs (5)

72if (Environment.GetEnvironmentVariable("DOTNET_ROOT") is string dotnetRoot && !string.IsNullOrEmpty(dotnetRoot)) 79referenceDirectories.Add(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "Reference Assemblies", "Microsoft", "Framework")); 80referenceDirectories.Add(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "dotnet", "packs"));

Microsoft.CodeAnalysis.Workspaces.MSBuild (9)

MSBuild\BuildHostProcessManager.cs (5)

134throw new Exception($"The build host was started but we were unable to connect to it's pipe. The process exited with {process.ExitCode}. Process output:{Environment.NewLine}{buildHostProcess.GetBuildHostProcessOutput()}", innerException: e); 188static string GetProcessPath() => Environment.ProcessPath ?? throw new InvalidOperationException("Unable to determine the path of the current process."); 260.Where(static key => key.StartsWith("DOTNET_ROOT", Environment.EnvironmentVariableComparison)) 579_logger.LogError("The BuildHost process is not responding. Process output:{newLine}{processLog}", Environment.NewLine, processLog); 581_logger.LogError("The BuildHost process exited with {errorCode}. Process output:{newLine}{processLog}", _process.ExitCode, Environment.NewLine, processLog);

MSBuild\DiagnosticReporterLoggerProvider.cs (1)

53message += Environment.NewLine + exception.ToString();

Rpc\RpcClient.cs (2)

67var message = $"Failed to deserialize response from build host:{Environment.NewLine}{line}"; 162var requestJson = JsonSerializer.Serialize(request, JsonSettings.SingleLineSerializerOptions) + Environment.NewLine;

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

13extension(Environment)

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

BuildHostLogger.cs (1)

34output.Write(Environment.NewLine);

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

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

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

MonoMSBuildDiscovery.cs (1)

29var path = Environment.GetEnvironmentVariable("PATH");

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

Microsoft.Data.Analysis (1)

TextFieldParser.cs (1)

181private readonly char[] _newLineChars = Environment.NewLine.ToCharArray();

Microsoft.Data.Analysis.Tests (1)

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

181private readonly char[] _newLineChars = Environment.NewLine.ToCharArray();

Microsoft.DiaSymReader (1)

SymUnmanagedFactory.cs (1)

119return Environment.GetEnvironmentVariable(name);

Microsoft.DotNet.ApiCompat.Task (4)

src\sdk\src\Tasks\Common\TaskBase.cs (4)

70Environment.NewLine, 74Environment.NewLine); 95s = s + " ---> " + ExceptionToStringWithoutMessage(e.InnerException) + Environment.NewLine + 104s += Environment.NewLine + stackTrace;

Microsoft.DotNet.ApiCompatibility (1)

Logging\SuppressionEngine.cs (1)

147xmlWriter.WriteWhitespace(Environment.NewLine);

Microsoft.DotNet.Arcade.Sdk (1)

src\GenerateResxSource.cs (1)

252namespaceStart = $@"namespace {namespaceName}{Environment.NewLine}{{";

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

src\CreateWixBuildWixpack.cs (1)

453File.WriteAllText(responseFilePath, string.Join(System.Environment.NewLine, commandLineArgs));

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

OptProf\GetRunSettingsSessionConfiguration.cs (3)

92$"Unable to read bootstrapper info: {e.Message}{Environment.NewLine}" + 93$"Content of BootstrapperInfo.json:{Environment.NewLine}" + 133Environment.NewLine,

Microsoft.DotNet.Cli.CoreUtils (2)

GracefulException.cs (2)

23: this(string.Join(Environment.NewLine, messages), isUserError: isUserError) 27VerboseMessage = string.Join(Environment.NewLine, verboseMessages);

Microsoft.DotNet.Cli.Definitions (14)

Commands\Test\TestCommandDefinition.cs (3)

35=> Create(Environment.CurrentDirectory, Environment.GetEnvironmentVariable(TestRunnerEnvironmentVariableName)); 38=> Create(startDirectory, Environment.GetEnvironmentVariable(TestRunnerEnvironmentVariableName));

Commands\Test\TestCommandDefinition.MicrosoftTestingPlatform.cs (1)

219Environment.GetEnvironmentVariable(EnableAffectedTestsEnvironmentVariable),

Common\CommonOptions.cs (2)

207string? configuration = Environment.GetEnvironmentVariable("Configuration"); 362DefaultValueFactory = (ar) => EnvironmentVariableParser.ParseBool(Environment.GetEnvironmentVariable("DOTNET_NOLOGO"), defaultValue),

Common\TargetPlatformOptions.cs (1)

112: Environment.GetEnvironmentVariable(key));

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

118getEnvironmentVariable = Environment.GetEnvironmentVariable; 126getEnvironmentVariable ??= Environment.GetEnvironmentVariable; 136currentProcessPath = Environment.ProcessPath;

Telemetry\EnvironmentDetectionRule.cs (4)

32return _variables.Any(variable => EnvironmentVariableParser.ParseBool(Environment.GetEnvironmentVariable(variable), defaultValue: false)); 50return _variables.All(variable => !string.IsNullOrEmpty(Environment.GetEnvironmentVariable(variable))); 68return _variables.Any(variable => !string.IsNullOrEmpty(Environment.GetEnvironmentVariable(variable))); 106var value = Environment.GetEnvironmentVariable(_variable);

Microsoft.DotNet.Cli.Utils (32)

AnsiConsole.cs (1)

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

DebugHelper.cs (1)

23int processId = Environment.ProcessId;

EnvironmentProvider.cs (9)

16private readonly Lazy<string> _userHomeDirectory = new(() => Environment.GetEnvironmentVariable("HOME") ?? string.Empty); 26? Environment.GetEnvironmentVariable("PATHEXT")? 44searchPaths.AddRange(Environment 109return Environment.GetEnvironmentVariable(name); 114var str = Environment.GetEnvironmentVariable(name); 137return Environment.GetEnvironmentVariable(variable, target); 142value = Environment.GetEnvironmentVariable(name); 148Environment.SetEnvironmentVariable(variable, value, target); 153if (Environment.GetEnvironmentVariable(variable) is string strValue && int.TryParse(strValue, out int intValue))

Extensions\AnsiExtensions.cs (1)

11var environment = Environment.GetEnvironmentVariable("TERM");

Extensions\LockFileFormatExtensions.cs (1)

20Environment.NewLine,

MSBuildForwardingAppWithoutLogging.cs (5)

242savedEnvironmentVariables[kvp.Key] = Environment.GetEnvironmentVariable(kvp.Key); 243Environment.SetEnvironmentVariable(kvp.Key, kvp.Value); 266Environment.SetEnvironmentVariable(kvp.Key, kvp.Value); 296var envMSBuildSDKsPath = Environment.GetEnvironmentVariable("MSBuildSDKsPath"); 323{ "MSBuildExtensionsPath", MSBuildExtensionsPathTestHook ?? Environment.GetEnvironmentVariable("MSBuildExtensionsPath") ?? SdkPaths.SdkDirectory },

Muxer.cs (3)

58string? processPath = Environment.ProcessPath; 68processPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH"); 72var root = Environment.GetEnvironmentVariable("DOTNET_ROOT");

PathUtility.cs (1)

358Environment.NewLine,

ProcessReaper.cs (1)

198Environment.ExitCode = _process.ExitCode;

RuntimeEnvironment.cs (3)

64return Environment.OSVersion.Version.ToString(3); 69return Environment.OSVersion.Version.ToString(2); 78return Environment.OSVersion.Version.ToString(1);

UILanguageOverride.cs (6)

80string? dotnetCliLanguage = Environment.GetEnvironmentVariable(DOTNET_CLI_UI_LANGUAGE); 92string? vsLang = Environment.GetEnvironmentVariable(VSLANG); 108string? currentValue = Environment.GetEnvironmentVariable(environmentVariableName); 111Environment.SetEnvironmentVariable(environmentVariableName, value); 122if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.OSVersion.Version.Major >= 10) // UTF-8 is only officially supported on 10+. 149return string.Equals(Environment.GetEnvironmentVariable("DOTNET_CLI_FORCE_UTF8_ENCODING"), "true", StringComparison.OrdinalIgnoreCase);

Microsoft.DotNet.Configurer (5)

CliFolderPathCalculator.cs (2)

17Environment.GetEnvironmentVariable("DOTNET_CLI_TEST_FALLBACKFOLDER") ?? 34return string.IsNullOrEmpty(Environment.GetEnvironmentVariable(DotnetHomeVariableName))

src\sdk\src\Common\CliFolderPathCalculatorCore.cs (3)

17: this(Environment.GetEnvironmentVariable) 59home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Microsoft.DotNet.HotReload.Watch (10)

Context\EnvironmentVariables.cs (9)

UI\ShutdownHandler.cs (1)

33Environment.Exit(0);

Microsoft.DotNet.HotReload.WebAssembly.Browser (7)

src\sdk\src\Dotnet.Watch\HotReloadAgent\HotReloadAgent.cs (6)

300var startupHooks = Environment.GetEnvironmentVariable(AgentEnvironmentVariables.DotNetStartupHooks); 303Environment.SetEnvironmentVariable(AgentEnvironmentVariables.DotNetStartupHooks, 307Environment.SetEnvironmentVariable(AgentEnvironmentVariables.DotNetWatchHotReloadNamedPipeName, null); 308Environment.SetEnvironmentVariable(AgentEnvironmentVariables.DotNetWatchHotReloadWebSocketEndpoint, null); 309Environment.SetEnvironmentVariable(AgentEnvironmentVariables.DotNetWatchHotReloadWebSocketKey, null); 310Environment.SetEnvironmentVariable(AgentEnvironmentVariables.HotReloadDeltaClientLogMessages, null);

WebAssemblyHotReload.cs (1)

67if (MetadataUpdater.IsSupported && Environment.GetEnvironmentVariable("__ASPNETCORE_BROWSER_TOOLS") == "true" &&

Microsoft.DotNet.NativeWrapper (3)

EnvironmentProvider.cs (3)

118getEnvironmentVariable = Environment.GetEnvironmentVariable; 126getEnvironmentVariable ??= Environment.GetEnvironmentVariable; 136currentProcessPath = Environment.ProcessPath;

Microsoft.DotNet.ProjectTools (3)

LaunchSettings\LaunchProfileParser.cs (1)

83string expandedValue = Environment.ExpandEnvironmentVariables(value);

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

157: Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

Microsoft.DotNet.SdkResolver (1)

NETCoreSdkResolver.cs (1)

25: this(Environment.GetEnvironmentVariable, VSSettings.Ambient)

Microsoft.DotNet.SharedFramework.Sdk (1)

src\ValidateFileVersions.cs (1)

90string.Concat(versionlessFiles.Select(f => Environment.NewLine + f)));

Microsoft.DotNet.TemplateLocator (9)

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

60: this(sdkRootPath, sdkVersion, Environment.GetEnvironmentVariable, userProfileDir, globalJsonPath) 66return new SdkDirectoryWorkloadManifestProvider(sdkRootPath, sdkVersion, Environment.GetEnvironmentVariable, userProfileDir, globalJsonPath: null, workloadSetVersion);

parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadInstallType.cs (2)

44return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "dotnet", "workloads", architecture, sdkFeatureBand.ToString(), "InstallState");

parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadResolver.cs (1)

45var packRootEnvironmentVariable = (getEnvironmentVariable ?? Environment.GetEnvironmentVariable)(EnvironmentVariableNames.WORKLOAD_PACK_ROOTS);

src\sdk\src\Common\EnvironmentVariableNames.cs (2)

TemplateLocator.cs (2)

19: this(Environment.GetEnvironmentVariable, null, VSSettings.Ambient, null, null) 56string? globalJsonPath = SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory);

Microsoft.DotNet.VersionTools.Cli (1)

Program.cs (1)

16RootCommand rootCommand = new("Microsoft.DotNet.VersionTools.Cli v" + Environment.Version.ToString(2))

Microsoft.Extensions.AI (1)

TelemetryHelpers.cs (1)

15Environment.GetEnvironmentVariable(OpenTelemetryConsts.GenAICaptureMessageContentEnvVar) is string envVar &&

Microsoft.Extensions.AI.Abstractions (1)

Contents\AIContentExtensions.cs (1)

86builder.AppendLiteral(Environment.NewLine);

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

ChatCompletion\ChatResponseTests.cs (1)

233ChatResponse response = new(new ChatMessage(ChatRole.Assistant, $"This is a test.{Environment.NewLine}It's multiple lines."));

SpeechToText\SpeechToTextResponseTests.cs (2)

196SpeechToTextResponse response = new("This is a test." + Environment.NewLine + "It's multiple lines."); 197Assert.Equal("This is a test." + Environment.NewLine + "It's multiple lines.", response.ToString());

test\Shared\JsonSchemaExporter\SchemaTestHelpers.cs (1)

47{string.Join(Environment.NewLine, errors)}

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

Commands\ReportCommand.cs (1)

146Environment.UserInteractive && (OperatingSystem.IsWindows() || !isRedirected);

Telemetry\DeviceIdHelper.cs (5)

136string? xdgCacheHome = Environment.GetEnvironmentVariable("XDG_CACHE_HOME"); 140string userProfilePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 158string userProfilePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Telemetry\EnvironmentHelper.cs (3)

16Environment.GetEnvironmentVariable(name)?.ToUpperInvariant() switch 48if (bool.TryParse(Environment.GetEnvironmentVariable(variable), out bool value) && value) 56if (Array.TrueForAll(variables, static variable => !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(variable))))

Telemetry\TelemetryConstants.cs (2)

124string? homeDirectoryPath = Environment.GetEnvironmentVariable("DOTNET_CLI_HOME"); 128Environment.GetEnvironmentVariable(

Telemetry\TelemetryHelper.cs (2)

51[TelemetryConstants.PropertyNames.OSVersion] = Environment.OSVersion.VersionString, 52[TelemetryConstants.PropertyNames.OSPlatform] = Environment.OSVersion.Platform.ToString(),

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

Setup.cs (1)

15Environment.GetEnvironmentVariable("AITESTING_OFFLINE") == "1";

Microsoft.Extensions.AI.Evaluation.Reporting.Tests (2)

EmbeddingTests.cs (1)

16Assert.SkipUnless(!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("TF_BUILD")), "Skipping test because it is not running in CI");

ScenarioRunResultTests.cs (1)

276string? witnessPath = Environment.GetEnvironmentVariable("AI_EVALUATION_DATASET_WITNESS_PATH");

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

ContentSafetyEvaluator.cs (1)

114string.Join(Environment.NewLine, textContents.Select(c => c.Text)) is string contextString &&

ContentSafetyServicePayloadUtilities.cs (1)

135userTextListStrings = [string.Join(Environment.NewLine, userTextListStrings)];

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

VerbatimHttpHandler.cs (3)

135$"Expected:{Environment.NewLine}" + 136$"{expected}{Environment.NewLine}" + 137$"Actual:{Environment.NewLine}" +

Microsoft.Extensions.AI.OpenAI (2)

OpenAIClientExtensions.cs (1)

92$"{descriptionNode.GetValue<string>()}{Environment.NewLine}{additionalDescription}" :

OpenAIResponsesChatClient.cs (1)

1013$"{result.Instructions}{Environment.NewLine}{instructions}";

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

AIChatWebExecutionTests.cs (1)

117string? envValue = System.Environment.GetEnvironmentVariable("AI_TEMPLATES_TEST_PROJECT_NAMES");

Microsoft.Extensions.AI.Tests (1)

ChatCompletion\ChatClientStructuredOutputExtensionsTests.cs (1)

419var resultDuplicatedJson = JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Options) + Environment.NewLine + JsonSerializer.Serialize(expectedResult, JsonContext2.Default.Options);

Microsoft.Extensions.Caching.Hybrid.Tests (2)

HybridCacheEventSourceTests.cs (2)

226log.WriteLine($".NET {Environment.Version} on {Environment.OSVersion}, {IntPtr.Size * 8}-bit");

Microsoft.Extensions.Configuration.EnvironmentVariables (1)

EnvironmentVariablesConfigurationProvider.cs (1)

68Load(Environment.GetEnvironmentVariables());

Microsoft.Extensions.Configuration.KeyPerFile (2)

KeyPerFileConfigurationProvider.cs (2)

55=> value.EndsWith(Environment.NewLine, StringComparison.Ordinal) 56? value.Substring(0, value.Length - Environment.NewLine.Length)

Microsoft.Extensions.Configuration.UserSecrets (7)

PathHelper.cs (7)

61string? appData = Environment.GetEnvironmentVariable("APPDATA"); 62string? home = Environment.GetEnvironmentVariable("HOME"); 72?? Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) 73?? Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) 74?? Environment.GetEnvironmentVariable(userSecretsFallbackDir); // this fallback is an escape hatch if everything else fails

Microsoft.Extensions.DataIngestion (4)

Chunkers\ElementsChunker.cs (4)

116AppendNewLineAndSpan(_currentChunk, tableBuilder.AsSpan(0, tableLength - Environment.NewLine.Length)); 140AppendNewLineAndSpan(_currentChunk, tableBuilder.AsSpan(0, tableLength - Environment.NewLine.Length)); 253vsb.Append(Environment.NewLine); 268vsb.Append(Environment.NewLine);

Microsoft.Extensions.DataIngestion.Abstractions (1)

IngestionDocumentElement.cs (1)

96=> string.Join(Environment.NewLine, Elements.Select(e => e.GetMarkdown()));

Microsoft.Extensions.DataIngestion.Tests (1)

Chunkers\SemanticSimilarityChunkerTests.cs (1)

102Assert.Equal(text1 + Environment.NewLine + text2, chunks[0].Content);

Microsoft.Extensions.DependencyInjection (2)

ServiceLookup\CallSiteFactory.cs (1)

692Environment.NewLine,

ServiceLookup\DynamicServiceProviderEngine.cs (1)

44Debug.Fail($"We should never get exceptions from the background compilation.{Environment.NewLine}{ex}");

Microsoft.Extensions.DependencyModel (3)

EnvironmentWrapper.cs (1)

15public string? GetEnvironmentVariable(string name) => Environment.GetEnvironmentVariable(name);

Resolution\PackageCompilationAssemblyResolver.cs (2)

59string basePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Microsoft.Extensions.Diagnostics.ResourceMonitoring (6)

Windows\Interop\ProcessInfo.cs (1)

40return (ulong)Environment.WorkingSet;

Windows\WindowsSnapshotProvider.cs (5)

101var cpuUsage = Environment.CpuUsage; 106memoryUsageInBytes: (ulong)Environment.WorkingSet); 120return Environment.CpuUsage.TotalTime.Ticks; 127internal static int GetCpuUnits() => Environment.ProcessorCount; 131return Environment.WorkingSet;

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

KubernetesMetadata.cs (1)

59var value = Environment.GetEnvironmentVariable(variableName);

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

TestKubernetesEnvironmentSetup.cs (2)

72Environment.SetEnvironmentVariable(name, value, EnvironmentVariableTarget.Process); 83Environment.SetEnvironmentVariable(variableName, null, EnvironmentVariableTarget.Process);

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

Windows\WindowsSnapshotProviderTests.cs (2)

49Assert.Equal(Environment.ProcessorCount, provider.Resources.GuaranteedCpuUnits); 50Assert.Equal(Environment.ProcessorCount, provider.Resources.MaximumCpuUnits);

Microsoft.Extensions.DotNetDeltaApplier (14)

src\sdk\src\Dotnet.Watch\HotReloadAgent.Host\Listener.cs (1)

132Environment.SetEnvironmentVariable(name, value);

src\sdk\src\Dotnet.Watch\HotReloadAgent.Host\StartupHook.cs (4)

21private static readonly string? s_standardOutputLogPrefix = Environment.GetEnvironmentVariable(AgentEnvironmentVariables.HotReloadDeltaClientLogMessages); 37var processPath = Environment.GetCommandLineArgs().FirstOrDefault(); 78Console.CancelKeyPress += (_, _) => Environment.Exit(0); 143Environment.Exit(0);

src\sdk\src\Dotnet.Watch\HotReloadAgent.Host\Transport.cs (3)

30var namedPipeName = Environment.GetEnvironmentVariable(AgentEnvironmentVariables.DotNetWatchHotReloadNamedPipeName); 37var webSocketEndpoint = Environment.GetEnvironmentVariable(AgentEnvironmentVariables.DotNetWatchHotReloadWebSocketEndpoint); 47var serverPublicKey = Environment.GetEnvironmentVariable(AgentEnvironmentVariables.DotNetWatchHotReloadWebSocketKey);

src\sdk\src\Dotnet.Watch\HotReloadAgent\HotReloadAgent.cs (6)

Microsoft.Extensions.FileProviders.Physical (1)

PhysicalFileProvider.cs (1)

184string? environmentValue = Environment.GetEnvironmentVariable(PollingEnvironmentKey);

Microsoft.Extensions.Hosting (3)

HostingHostBuilderExtensions.cs (2)

221string cwd = Environment.CurrentDirectory; 228!string.Equals(cwd, Environment.SystemDirectory, StringComparison.OrdinalIgnoreCase))

Internal\HostingLoggerExtensions.cs (1)

21message = message + Environment.NewLine + ex.Message;

Microsoft.Extensions.Hosting.Systemd (9)

SystemdHelpers.cs (7)

29if (Environment.OSVersion.Platform != PlatformID.Unix) 34int processId = Environment.ProcessId; 38string? systemdExecPid = Environment.GetEnvironmentVariable(SystemdConstants.SystemdExecPid); 55return !string.IsNullOrEmpty(Environment.GetEnvironmentVariable(SystemdConstants.NotifySocket)) || 56!string.IsNullOrEmpty(Environment.GetEnvironmentVariable(SystemdConstants.ListenPid)); 86if (Environment.OSVersion.Platform != PlatformID.Unix) 91string? socketPath = Environment.GetEnvironmentVariable(SystemdConstants.NotifySocket);

SystemdHostBuilderExtensions.cs (1)

126Environment.SetEnvironmentVariable(SystemdConstants.NotifySocket, null);

SystemdNotifier.cs (1)

61string? socketPath = Environment.GetEnvironmentVariable(SystemdConstants.NotifySocket);

Microsoft.Extensions.Hosting.WindowsServices (1)

Internal\Win32.cs (1)

26int currentProcessId = Environment.ProcessId;

Microsoft.Extensions.Http (3)

DependencyInjection\SocketsHttpHandlerBuilderExtensions.cs (1)

36string message = SR.Format(SR.SocketsHttpHandlerBuilder_PrimaryHandlerIsInvalid, nameof(b.PrimaryHandler), typeof(SocketsHttpHandler).FullName, Environment.NewLine, b.PrimaryHandler?.ToString() ?? "(null)");

HttpMessageHandlerBuilder.cs (1)

109Environment.NewLine,

src\runtime\src\libraries\Common\src\System\Net\Http\UriRedactionHelper.cs (1)

20string? envVar = Environment.GetEnvironmentVariable("DOTNET_SYSTEM_NET_HTTP_DISABLEURIREDACTION");

Microsoft.Extensions.Logging.AzureAppServices (4)

BatchingLoggerProvider.cs (1)

103_currentBatch.Add(new LogMessage(DateTimeOffset.Now, $"{messagesDropped} message(s) dropped because of queue size limit. Increase the queue size or decrease logging verbosity to avoid this.{Environment.NewLine}"));

WebAppContext.cs (3)

21public string HomeFolder { get; } = Environment.GetEnvironmentVariable("HOME"); 24public string SiteName { get; } = Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME"); 27public string SiteInstanceId { get; } = Environment.GetEnvironmentVariable("WEBSITE_INSTANCE_ID");

Microsoft.Extensions.Logging.Console (14)

ConsoleLoggerProcessor.cs (1)

133message: SR.Format(SR.WarningMessageOnDrop + Environment.NewLine, _messagesDropped),

JsonConsoleFormatter.cs (1)

116textWriter.Write(Environment.NewLine);

SimpleConsoleFormatter.cs (7)

17private static readonly string _newLineWithMessagePadding = Environment.NewLine + _messagePadding; 115textWriter.Write(Environment.NewLine); 132textWriter.Write(Environment.NewLine); 143WriteReplacing(textWriter, Environment.NewLine, " ", message); 148WriteReplacing(textWriter, Environment.NewLine, _newLineWithMessagePadding, message); 149textWriter.Write(Environment.NewLine); 228textWriter.Write(Environment.NewLine);

src\runtime\src\libraries\Common\src\System\Console\ConsoleUtils.cs (3)

46if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("FORCE_COLOR")) || 47!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION"))) 53if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("NO_COLOR")))

SystemdConsoleFormatter.cs (2)

108textWriter.Write(Environment.NewLine); 112string newMessage = message.Replace(Environment.NewLine, " ");

Microsoft.Extensions.Logging.Debug (2)

DebugLogger.cs (2)

68message = $"{logLevel}: {formatted}{Environment.NewLine}{Environment.NewLine}{exception}";

Microsoft.Extensions.ML.Tests (1)

PredictionEnginePoolTests.cs (1)

91var maximumRetained = Environment.ProcessorCount * 2;

Microsoft.Extensions.ObjectPool (5)

DefaultObjectPool.cs (1)

30: this(policy, Environment.ProcessorCount * 2)

DefaultObjectPoolProvider.cs (1)

17public int MaximumRetained { get; set; } = Environment.ProcessorCount * 2;

LeakTrackingObjectPool.cs (3)

65_stack = Environment.StackTrace; 76if (!_disposed && !Environment.HasShutdownStarted) 78Debug.Fail($"{typeof(T).Name} was leaked. Created at: {Environment.NewLine}{_stack}");

Microsoft.Extensions.ServiceDiscovery.Dns (3)

DnsSrvServiceEndpointProviderFactory.cs (2)

126var host = Environment.GetEnvironmentVariable("KUBERNETES_SERVICE_HOST"); 127var port = Environment.GetEnvironmentVariable("KUBERNETES_SERVICE_PORT");

ServiceDiscoveryDnsServiceCollectionExtensions.cs (1)

141var envVar = Environment.GetEnvironmentVariable("MICROSOFT_EXTENSIONS_SERVICE_DISCOVERY_DNS_USE_DNSCLIENT_FALLBACK");

Microsoft.Extensions.ServiceDiscovery.Dns.Tests (3)

XunitLoggerFactoryExtensions.cs (3)

63private static readonly string[] s_newLineChars = new[] { Environment.NewLine }; 114if (message.EndsWith(Environment.NewLine, StringComparison.Ordinal)) 116message = message.Substring(0, message.Length - Environment.NewLine.Length);

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

Program.cs (1)

28{string.Join(Environment.NewLine, fuzzers.Select(f => $" {f.Name}"))}

Microsoft.Extensions.Telemetry (6)

Enrichment\ProcessLogEnricher.cs (1)

32_threadId ??= Environment.CurrentManagedThreadId.ToInvariantString();

Enrichment\StaticProcessLogEnricher.cs (1)

25var pid = Environment.ProcessId;

Latency\Internal\LatencyConsoleExporter.cs (2)

20private static readonly CompositeFormat _title = CompositeFormat.Parse("Latency sample #{0}: {1}ms, {2} checkpoints, {3} tags, {4} measures" + Environment.NewLine); 21private static readonly Func<int, CompositeFormat> _rows = Memoize.Function((int nameColumnWidth) => CompositeFormat.Parse($" {{0,-{nameColumnWidth}}} | {{1}}" + Environment.NewLine));

Logging\ExtendedLogger.cs (2)

186trace = trace.Replace(Environment.NewLine, Environment.NewLine + indentStr + " ", StringComparison.Ordinal).Trim(' ');

Microsoft.Extensions.Telemetry.Tests (1)

Latency\Internal\LatencyConsoleExporterTests.cs (1)

155private static string NormalizeLineEndings(string value) => value.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", Environment.NewLine);

Microsoft.Extensions.VectorData.ConformanceTests (1)

TestSuiteImplementationTests.cs (1)

34"\r\n-- Missing derived classes for --\r\n" + string.Join(Environment.NewLine, nonImplementedBases));

Microsoft.Gen.MetricsReports.Unit.Tests (1)

EmitterTests.cs (1)

131string newLine = Environment.NewLine;

Microsoft.Maui (2)

Animations\AnimationManager.cs (1)

68 Environment.TickCount & int.MaxValue;

VisualDiagnostics\VisualDiagnostics.cs (1)

16 static Lazy<bool> isVisualDiagnosticsEnvVarSet = new Lazy<bool>(() => Environment.GetEnvironmentVariable("ENABLE_XAML_DIAGNOSTICS_SOURCE_INFO") is { } value && value == "1");

Microsoft.Maui.Resizetizer (5)

AppleIconAssetsGenerator.cs (1)

78 {{string.Join("," + Environment.NewLine, appIconImagesJson)}}

AsyncTask.cs (1)

69 LogError(ex.Message + Environment.NewLine + ex.StackTrace);

GenerateTizenManifest.cs (1)

61 _tizenManifestFilePath = Path.Combine(Environment.CurrentDirectory, TizenManifestFile);

SkiaSharpTools.cs (2)

30 var retryVariable = Environment.GetEnvironmentVariable("DOTNET_ANDROID_FILE_WRITE_RETRY_ATTEMPTS"); 47 var delayVariable = Environment.GetEnvironmentVariable("DOTNET_ANDROID_FILE_WRITE_RETRY_DELAY_MS");

Microsoft.ML.AutoML (2)

AutoMLExperiment\IPerformanceMonitor.cs (1)

125var cpuUsageInTotal = cpuUsedMs / (Environment.ProcessorCount * _checkIntervalInMilliseconds);

AutoMlUtils.cs (1)

22var res = Environment.GetEnvironmentVariable(MLNetMaxThread);

Microsoft.ML.AutoML.SourceGenerator (15)

Template\EstimatorType.cs (3)

168if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 180textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Template\SearchSpace.cs (3)

185if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 197textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Template\SweepableEstimator_T_.cs (3)

192if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 204textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Template\SweepableEstimator.cs (3)

187if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 199textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Template\SweepableEstimatorFactory.cs (3)

163if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 175textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Microsoft.ML.AutoML.Tests (6)

AutoFeaturizerTests.cs (1)

35if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

ColumnInferenceTests.cs (1)

240if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

SweepableEstimatorPipelineTest.cs (1)

38if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

SweepableExtensionTest.cs (1)

40if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

SweepablePipelineTests.cs (1)

35if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

TrialResultManagerTest.cs (1)

83fileContent = fileContent.Replace(Environment.NewLine, "\r");

Microsoft.ML.CodeGenerator (30)

Templates\Azure\Console\AzureModelBuilder.cs (3)

262if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 274textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Templates\Azure\Model\AzureImageModelOutputClass.cs (3)

203if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 215textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Templates\Azure\Model\AzureObjectDetectionModelOutputClass.cs (3)

Templates\Console\ConsumeModel.cs (3)

214if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 226textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Templates\Console\ModelBuilder.cs (3)

579if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 591textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Templates\Console\ModelInputClass.cs (3)

177if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 189textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Templates\Console\ModelOutputClass.cs (3)

220if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 232textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Templates\Console\ModelProject.cs (3)

209if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 221textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Templates\Console\PredictProgram.cs (3)

236if (textToAppend.EndsWith(global::System.Environment.NewLine, global::System.StringComparison.CurrentCulture)) 248textToAppend = textToAppend.Replace(global::System.Environment.NewLine, (global::System.Environment.NewLine + this.currentIndentField));

Templates\Console\PredictProject.cs (3)

Microsoft.ML.CodeGenerator.Tests (2)

ApprovalTests\ConsoleCodeGeneratorTests.cs (1)

42if (System.Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

ApprovalTests\TemplateTest.cs (1)

24if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

Microsoft.ML.Core (12)

ComponentModel\ComponentCatalog.cs (2)

1063errorMsg = err + Environment.NewLine + "Usage For '" + name + "':" + Environment.NewLine + helpText;

Utilities\PathUtils.cs (1)

78var envDir = Environment.GetEnvironmentVariable(CustomSearchDirEnvVariable);

Utilities\ResourceManagerUtils.cs (9)

45var envUrl = Environment.GetEnvironmentVariable(CustomResourcesUrlEnvVariable); 104/// a folder called "mlnet-resources" in the <see cref="Environment.SpecialFolder.ApplicationData"/> directory.</param> 192var envTimeout = Environment.GetEnvironmentVariable(TimeoutEnvVariable); 200/// inside <see cref="Environment.SpecialFolder.LocalApplicationData"/>\mlnet-resources\. 204var envDir = Environment.GetEnvironmentVariable(Utils.CustomSearchDirEnvVariable); 205var appDataBaseDir = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); 218if (Environment.OSVersion.Platform == PlatformID.Unix) 237if (Environment.OSVersion.Platform == PlatformID.Unix)

Microsoft.ML.Core.Tests (14)

UnitTests\TestEntryPoints.cs (1)

346.Replace(Environment.NewLine, ""))

UnitTests\TestResourceDownload.cs (13)

Microsoft.ML.CpuMath.PerformanceTests (1)

PerformanceTests.cs (1)

51string cpumathSeed = Environment.GetEnvironmentVariable("CPUMATH_SEED");

Microsoft.ML.CpuMath.UnitTests (3)

UnitTests.cs (3)

36public static bool IsNetCore => Environment.Version.Major >= 5 || RuntimeInformation.FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase); 37public static bool IsNetCore2OrOlder => Environment.Version.Major == 4 && Environment.Version.Minor == 0;

Microsoft.ML.Data (6)

Data\DataViewUtils.cs (1)

100int conc = Math.Max(2, Environment.ProcessorCount - 1);

DataLoadSave\Binary\BinaryLoader.cs (3)

783_threads = Math.Max(1, args.Threads ?? (Environment.ProcessorCount / 2)); 849_threads = Math.Max(1, Environment.ProcessorCount / 2); 857_threads = Math.Max(1, Environment.ProcessorCount / 2);

DataLoadSave\Binary\BinarySaver.cs (1)

667Task[] compressionThreads = new Task[Environment.ProcessorCount];

Dirty\ModelParametersBase.cs (1)

88ch.Warning(NormalizerWarningFormat, typePredictor, Environment.NewLine);

Microsoft.ML.FastTree (4)

FastTree.cs (2)

185InitializeThreads(FastTreeTrainerOptions.NumberOfThreads ?? Environment.ProcessorCount); 817ch.Trace("Host = {0}", Environment.MachineName);

GamTrainer.cs (1)

604ThreadTaskManager.Initialize(GamTrainerOptions.NumberOfThreads ?? Environment.ProcessorCount);

SumupPerformanceCommand.cs (1)

99_parallel = args.Parallel ?? Environment.ProcessorCount;

Microsoft.ML.GenAI.LLaMA.Tests (2)

LLaMA3_1Tests.cs (1)

24if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

LLaMA3_2Tests.cs (1)

19if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

Microsoft.ML.GenAI.Mistral.Tests (1)

Mistral_7B_Instruct_V0_3Tests.cs (1)

21if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

Microsoft.ML.GenAI.Phi.Tests (2)

Phi2Tests.cs (1)

21if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

Phi3Tests.cs (1)

22if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null)

Microsoft.ML.KMeansClustering (1)

KMeansPlusPlusTrainer.cs (1)

278int maxThreads = Environment.ProcessorCount / 2;

Microsoft.ML.Mkl.Components (1)

SymSgdClassificationTrainer.cs (1)

705int numThreads = _options.NumberOfThreads ?? Environment.ProcessorCount;

Microsoft.ML.OneDal (3)

OneDalUtils.cs (3)

23if (Environment.GetEnvironmentVariable("MLNET_BACKEND") == "ONEDAL" && 34var originalPath = Environment.GetEnvironmentVariable("PATH"); 35Environment.SetEnvironmentVariable("PATH", nativeLibs + ";" + originalPath);

Microsoft.ML.OnnxTransformerTest (2)

DnnImageFeaturizerTest.cs (2)

62if (!Environment.Is64BitProcess) 138if (!Environment.Is64BitProcess)

Microsoft.ML.PerformanceTests (1)

Harness\ProjectGenerator.cs (1)

70return string.Join(Environment.NewLine, File.ReadAllLines(csproj.FullName).Where(line => line.Contains("<NativeAssemblyReference")));

Microsoft.ML.Recommender (2)

MatrixFactorizationTrainer.cs (2)

366_threads = options.NumberOfThreads ?? Environment.ProcessorCount; 408_threads = args.NumberOfThreads ?? Environment.ProcessorCount;

Microsoft.ML.Samples (2)

Dynamic\Transforms\NormalizeMinMaxMulticolumn.cs (2)

87Console.WriteLine(Environment.NewLine); 109Console.WriteLine(Environment.NewLine);

Microsoft.ML.SearchSpace.Tests (3)

TestBase.cs (3)

19if (Environment.GetEnvironmentVariable("HELIX_CORRELATION_ID") != null) 39var cwd = Environment.CurrentDirectory; 51var cwd = Environment.CurrentDirectory;

Microsoft.ML.StandardTrainers (6)

Standard\LogisticRegression\LbfgsPredictorBase.cs (3)

451if (Environment.GetEnvironmentVariable("MLNET_BACKEND") == "ONEDAL" && 469int numThreads = !UseThreads ? 1 : (NumThreads ?? Environment.ProcessorCount); 570int numThreads = !UseThreads ? 1 : (NumThreads ?? Environment.ProcessorCount);

Standard\SdcaBinary.cs (1)

141=> Math.Min(8, Math.Max(1, Environment.ProcessorCount / 2));

Standard\SdcaRegression.cs (1)

171=> Math.Min(2, Math.Max(1, Environment.ProcessorCount / 2));

Standard\StochasticTrainerBase.cs (1)

48=> Math.Min(8, Math.Max(1, Environment.ProcessorCount / 2));

Microsoft.ML.Sweeper (1)

ConfigRunner.cs (1)

207RunProcess(Exe, new string[] { arguments }, Environment.CurrentDirectory,

Microsoft.ML.TestFramework (14)

Attributes\BenchmarkTheoryAttribute.cs (1)

20private readonly bool _isEnvironmentSupported = System.Environment.Is64BitProcess;

Attributes\LightGBMFactAttribute.cs (1)

23return Environment.Is64BitProcess && NativeLibrary.NativeLibraryExists("lib_lightgbm");

Attributes\LightGBMTheoryAttribute.cs (1)

23return Environment.Is64BitProcess && NativeLibrary.NativeLibraryExists("lib_lightgbm");

Attributes\TensorflowFactAttribute.cs (1)

23return (Environment.Is64BitProcess &&

Attributes\TensorflowTheoryAttribute.cs (1)

23return (Environment.Is64BitProcess &&

Attributes\TorchSharpFactAttribute.cs (1)

28return (Environment.Is64BitProcess &&

BaseTestBaseline.cs (7)

150if (!Environment.Is64BitProcess) 166if (Environment.Is64BitProcess) 660var message = iterationOnCollection != null ? "" : $"Output and baseline mismatch at line {iterationOnCollection}." + Environment.NewLine; 664$"Values to compare are {expected} and {actual}" + Environment.NewLine + 665$"\t AllowedVariance: {allowedVariance}" + Environment.NewLine + 666$"\t delta: {delta}" + Environment.NewLine + 667$"\t delta2: {delta2}" + Environment.NewLine);

GlobalBase.cs (1)

34Environment.SetEnvironmentVariable("MKL_CBWR", "COMPATIBLE");

Microsoft.ML.TestFrameworkCommon (6)

Attributes\X64FactAttribute.cs (1)

22return Environment.Is64BitProcess && System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture == System.Runtime.InteropServices.Architecture.X64;

parent\parent\src\Common\tests\RetryHelper.cs (1)

17private static readonly bool _debug = Environment.GetEnvironmentVariable("DEBUG_RETRYHELPER") == "1";

TestCommon.cs (1)

65string directory = Environment.GetEnvironmentVariable(TestDataDirEnvVariable);

Utility\NativeLibrary.cs (1)

24else if (Environment.OSVersion.Platform == PlatformID.Unix)

Utility\PathResolver.cs (2)

151return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".nuget", "packages");

Microsoft.ML.Tests (7)

OnnxConversionTest.cs (6)

199if (Environment.Is64BitProcess && NativeLibrary.NativeLibraryExists("lib_lightgbm")) 240if (Environment.Is64BitProcess && NativeLibrary.NativeLibraryExists("lib_lightgbm")) 295if (Environment.Is64BitProcess) 1673if (Environment.Is64BitProcess && NativeLibrary.NativeLibraryExists("lib_lightgbm")) 1951if (Environment.Is64BitProcess && NativeLibrary.NativeLibraryExists("lib_lightgbm")) 2000if (Environment.Is64BitProcess && NativeLibrary.NativeLibraryExists("lib_lightgbm"))

TrainerEstimators\OneDalEstimators.cs (1)

36Environment.SetEnvironmentVariable("MLNET_BACKEND", "ONEDAL");

Microsoft.ML.Tokenizers (4)

Model\CodeGenTokenizer.cs (2)

1756throw new ArgumentException($"Problems met when parsing JSON vocabulary object.{Environment.NewLine}Error message: {e.Message}"); 1796throw new IOException($"Cannot read the file Merge file.{Environment.NewLine}Error message: {e.Message}", e);

Model\EnglishRobertaTokenizer.cs (2)

188throw new ArgumentException($"Problems met when parsing JSON vocabulary object.{Environment.NewLine}Error message: {e.Message}"); 228throw new IOException($"Cannot read the file Merge file.{Environment.NewLine}Error message: {e.Message}", e);

Microsoft.ML.Tokenizers.Data.Tests (1)

parent\parent\src\Common\tests\RetryHelper.cs (1)

17private static readonly bool _debug = Environment.GetEnvironmentVariable("DEBUG_RETRYHELPER") == "1";

Microsoft.ML.Tokenizers.Tests (3)

BpeTests.cs (2)

614string result = $"[{string.Join(", ", encoding.Select(t => $"{t.Id}"))} ] {Environment.NewLine}"; 615result += $"[{string.Join(", ", encoding.Select(t => $"\"{t.Value}\""))} ] {Environment.NewLine}";

parent\parent\src\Common\tests\RetryHelper.cs (1)

17private static readonly bool _debug = Environment.GetEnvironmentVariable("DEBUG_RETRYHELPER") == "1";

Microsoft.NET.Build.Containers (20)

AuthHandshakeMessageHandler.cs (2)

397var credU = Environment.GetEnvironmentVariable(unameVar); 398var credP = Environment.GetEnvironmentVariable(passwordVar);

ContentStore.cs (8)

95string? xdgCacheHome = Environment.GetEnvironmentVariable("XDG_CACHE_HOME"); 102string userHomeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 110string userHomeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 115string localAppData = Environment.GetFolderPath( 116Environment.SpecialFolder.LocalApplicationData, 117Environment.SpecialFolderOption.DoNotVerify);

LocalDaemons\ContainerRuntimeOperations.cs (1)

159foreach (string directory in (Environment.GetEnvironmentVariable("PATH") ?? string.Empty).Split(Path.PathSeparator))

LocalDaemons\ContainerRuntimes.cs (1)

88string messages = string.Join(Environment.NewLine, errorProperty.EnumerateArray());

LocalDaemons\DockerCli.cs (2)

56foreach (string directory in (Environment.GetEnvironmentVariable("PATH") ?? string.Empty).Split(Path.PathSeparator)) 169string messages = string.Join(Environment.NewLine, errorProperty.EnumerateArray());

Registry\RegistrySettings.cs (2)

16ForceChunkedUpload = Environment.GetEnvironmentVariable(EnvVariables.ForceChunkedUpload) is not null ? 19ParallelUploadEnabled = Environment.GetEnvironmentVariable(EnvVariables.ParallelUploadEnabled) is not null ?

Tasks\CreateNewImage.cs (4)

75Environment.SetEnvironmentVariable(ContainerHelpers.HostObjectUser, userName); 76Environment.SetEnvironmentVariable(ContainerHelpers.HostObjectPass, pass); 93Environment.SetEnvironmentVariable(ContainerHelpers.HostObjectUser, null); 94Environment.SetEnvironmentVariable(ContainerHelpers.HostObjectPass, null);

Microsoft.NET.Build.Extensions.Tasks (4)

parent\Common\TaskBase.cs (4)

70Environment.NewLine, 74Environment.NewLine); 95s = s + " ---> " + ExceptionToStringWithoutMessage(e.InnerException) + Environment.NewLine + 104s += Environment.NewLine + stackTrace;

Microsoft.NET.Build.Tasks (19)

CheckSdkVulnerabilities.cs (1)

28if (bool.TryParse(Environment.GetEnvironmentVariable(Microsoft.DotNet.Cli.EnvironmentVariableNames.SDK_VULNERABILITY_CHECK_DISABLE), out bool disabled) && disabled)

FrameworkPackages\FrameworkPackages.cs (1)

135log.LogMessage("Pack directories found: {0}", string.Join(Environment.NewLine, packDirectories.Select(d => Path.Combine(originalPacksFolder, Path.GetFileName(d)))));

GenerateRuntimeConfigurationFiles.cs (1)

424NewLine = Environment.NewLine,

parent\Common\TaskBase.cs (4)

70Environment.NewLine, 74Environment.NewLine); 95s = s + " ---> " + ExceptionToStringWithoutMessage(e.InnerException) + Environment.NewLine + 104s += Environment.NewLine + stackTrace;

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

parent\parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadInstallType.cs (2)

44return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "dotnet", "workloads", architecture, sdkFeatureBand.ToString(), "InstallState");

parent\parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadResolver.cs (1)

45var packRootEnvironmentVariable = (getEnvironmentVariable ?? Environment.GetEnvironmentVariable)(EnvironmentVariableNames.WORKLOAD_PACK_ROOTS);

ProcessFrameworkReferences.cs (1)

704string.Join(Environment.NewLine, matchingRuntimePacks.Select(rp => rp.RuntimePackNamePatterns)));

ShowMissingWorkloads.cs (1)

45string globalJsonPath = SdkDirectoryWorkloadManifestProvider.GetGlobalJsonPath(Environment.CurrentDirectory);

src\sdk\src\Common\CliFolderPathCalculatorCore.cs (3)

17: this(Environment.GetEnvironmentVariable) 59home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

src\sdk\src\Common\EnvironmentVariableNames.cs (2)

Microsoft.NET.HostModel (2)

Bundle\Bundler.cs (1)

59_outputDir = Path.GetFullPath(string.IsNullOrEmpty(outputDir) ? Environment.CurrentDirectory : outputDir);

Bundle\TargetInfo.cs (1)

36FrameworkVersion = targetFrameworkVersion ?? Environment.Version;

Microsoft.NET.ProjectData (21)

CachePathResolver.cs (11)

1260 string? nugetPackages = Environment.GetEnvironmentVariable("NUGET_PACKAGES"); 1266 string userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 1285 string? dotnetRoot = Environment.GetEnvironmentVariable("DOTNET_ROOT"); 1293 string programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); 1305 string? userHome = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 1308 userHome = Environment.GetEnvironmentVariable("HOME"); 1322 string programFilesX86 = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);

Donor\ProjectDataDonorOptions.cs (1)

17 Environment.GetEnvironmentVariable(ProjectDataDonorConfiguration.EnabledEnvironmentVariableName));

Donor\ProjectDataDonorWriteOptions.cs (1)

10 Environment.GetEnvironmentVariable(ProjectDataDonorConfiguration.EnabledEnvironmentVariableName));

UserFolderCachePath.cs (8)

82 string? envOverride = Environment.GetEnvironmentVariable(CacheBaseDirectoryEnvVar); 90 string localAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); 98 string home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 106 string? xdgCacheHome = Environment.GetEnvironmentVariable(XdgCacheHomeEnvVar); 112 string home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Microsoft.NET.ProjectData.Tasks (21)

CachePathResolver.cs (12)

291 string? envVal = Environment.GetEnvironmentVariable("NUGET_PACKAGES"); 295 string userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 314 Add(Environment.GetEnvironmentVariable("DOTNET_ROOT")); 315 Add(TryGetDotNetRootFromHostPath(Environment.GetEnvironmentVariable("DOTNET_HOST_PATH"))); 319 string programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); 327 string userHome = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 328 if (string.IsNullOrEmpty(userHome)) userHome = Environment.GetEnvironmentVariable("HOME") ?? string.Empty; 352 string pfx86 = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);

src\roslyn\src\ProjectData\Microsoft.NET.ProjectData\Donor\ProjectDataDonorWriteOptions.cs (1)

10 Environment.GetEnvironmentVariable(ProjectDataDonorConfiguration.EnabledEnvironmentVariableName));

src\roslyn\src\ProjectData\Microsoft.NET.ProjectData\UserFolderCachePath.cs (8)

Microsoft.NET.Sdk.BlazorWebAssembly.Tasks (2)

BrotliCompress.cs (1)

44_dotnetPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH");

GenerateServiceWorkerAssetsManifest.cs (1)

68Environment.NewLine,

Microsoft.NET.Sdk.Publish.Tasks (16)

EnvironmentHelper.cs (2)

10return Environment.GetEnvironmentVariable(name); 15var str = Environment.GetEnvironmentVariable(name);

MsDeploy\CommonUtility.cs (2)

1680strBuilder.Append(Environment.NewLine); 1686strBuilder.Append(Environment.NewLine);

src\sdk\src\Common\EnvironmentVariableNames.cs (2)

Tasks\GenerateEFSQLScripts.cs (3)

86string? previousAspNetCoreEnvironment = Environment.GetEnvironmentVariable(AspNetCoreEnvironment); 87Environment.SetEnvironmentVariable(AspNetCoreEnvironment, "Development"); 134Environment.SetEnvironmentVariable(AspNetCoreEnvironment, previousAspNetCoreEnvironment);

Tasks\MsDeploy\CreateMSDeployScript.cs (1)

45var lines = fileContents.Split(new string[] { Environment.NewLine, "\n" }, StringSplitOptions.None);

Tasks\MsDeploy\MSDeploy.cs (6)

265string programFiles = Environment.ExpandEnvironmentVariables("%ProgramFiles(x86)%"); 272if (!Environment.Is64BitOperatingSystem || Environment.Is64BitProcess) 274programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); 280programFiles = Environment.ExpandEnvironmentVariables("%ProgramW6432%");

Microsoft.NET.Sdk.Razor.Tasks (18)

DotnetToolTask.cs (5)

61var dotnetHostPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH"); 85var processId = Environment.ProcessId; 236var lines = output.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); 249var lines = output.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); 277var list = responseFileCommands.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

parent\Tool\PipeName.cs (1)

34var userName = Environment.UserName;

parent\Tool\ServerProtocol\ServerConnection.cs (8)

57var tmp = Environment.GetEnvironmentVariable("TMP"); 63var temp = Environment.GetEnvironmentVariable("TEMP"); 82var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 88return Environment.GetEnvironmentVariable("SYSTEMROOT"); 281var expectedPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH"); 288expectedPath = System.Environment.ProcessPath; 301var paths = Environment.GetEnvironmentVariable("PATH").Split(Path.PathSeparator);

parent\Tool\ServerProtocol\ServerLogger.cs (4)

37var loggingFileName = Environment.GetEnvironmentVariable(EnvironmentVariable); 113GetCurrentProcessId(), Environment.CurrentManagedThreadId, Environment.TickCount); 128Environment.ProcessId;

Microsoft.NET.Sdk.StaticWebAssets.Tasks (24)

Compression\BrotliCompress.cs (1)

35_dotnetPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH");

ComputeReferenceStaticWebAssetItems.cs (2)

91Environment.NewLine + string.Join(Environment.NewLine, all.Select(a => $"({a.Identity},{a.AssetKind})")));

ComputeStaticWebAssetsForCurrentProject.cs (2)

60Environment.NewLine + string.Join(Environment.NewLine, all.Select(a => $"({a.Identity},{a.AssetKind})")));

DefineStaticWebAssets.cs (6)

538var errorMessage = "More than two assets are targeting the same path: " + Environment.NewLine + 539"'{0}' with kind '{1}'" + Environment.NewLine + 540"'{2}' with kind '{3}'" + Environment.NewLine + 560var errorMessage = "Two assets found targeting the same path with incompatible asset kinds:" + Environment.NewLine + 561"'{0}' with kind '{1}'" + Environment.NewLine + 562"'{2}' with kind '{3}'" + Environment.NewLine +

GenerateStaticWebAssetEndpointsManifest.cs (1)

202return (string.Join(Environment.NewLine, parsed), parsed);

JSModules\ApplyJsModules.cs (4)

71Environment.NewLine + 72string.Join(Environment.NewLine, jsModuleFiles.Select(f => f.ItemSpec))); 84Environment.NewLine + 85string.Join(Environment.NewLine, jsModuleFiles.Select(f => f.ItemSpec)));

OverrideHtmlAssetPlaceholders.cs (1)

151return String.Join(Environment.NewLine, links.Select(l => l.Value));

ScopedCss\ApplyCssScopes.cs (4)

74Environment.NewLine + 75string.Join(Environment.NewLine, scopeFiles.Select(f => f.ItemSpec))); 87Environment.NewLine + 88string.Join(Environment.NewLine, scopeFiles.Select(f => f.ItemSpec)));

ServiceWorker\GenerateServiceWorkerAssetsManifest.cs (2)

81Environment.NewLine, 100var content = $"self.assetsManifest = {data};{Environment.NewLine}";

ServiceWorker\UpdateServiceWorkerFileWithVersion.cs (1)

32var versionedContent = $"/* Manifest version: {ManifestVersion} */{Environment.NewLine}{sourceContent}";

Microsoft.NET.Sdk.WorkloadManifestReader (7)

SdkDirectoryWorkloadManifestProvider.cs (2)

src\sdk\src\Common\EnvironmentVariableNames.cs (2)

WorkloadInstallType.cs (2)

44return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "dotnet", "workloads", architecture, sdkFeatureBand.ToString(), "InstallState");

WorkloadResolver.cs (1)

45var packRootEnvironmentVariable = (getEnvironmentVariable ?? Environment.GetEnvironmentVariable)(EnvironmentVariableNames.WORKLOAD_PACK_ROOTS);

Microsoft.NET.Sdk.WorkloadMSBuildSdkResolver (5)

CachingWorkloadResolver.cs (1)

69var envVar = Environment.GetEnvironmentVariable("MSBuildEnableWorkloadResolver");

src\sdk\src\Common\CliFolderPathCalculatorCore.cs (3)

17: this(Environment.GetEnvironmentVariable) 59home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

WorkloadSdkResolver.cs (1)

109string? startDir = Environment.CurrentDirectory;

Microsoft.NET.StringTools (2)

WeakStringCache.Concurrent.cs (2)

23_stringsByHashCode = new ConcurrentDictionary<int, string>(Environment.ProcessorCount, _initialCapacity); 24_weakHandlesByHashCode = new ConcurrentDictionary<int, StringWeakHandle>(Environment.ProcessorCount, _initialCapacity);

Microsoft.Private.Windows.Core (7)

src\winforms\src\Microsoft.Private.Windows.Polyfills\System\OperatingSystemExtensions.cs (2)

11/// Checks whether the Windows version (returned by <see cref="Environment.OSVersion"/>) is greater than 25Version current = Environment.OSVersion.Version;

Windows\Win32\Graphics\GdiPlus\GdiplusStartupInputEx.cs (1)

10OperatingSystem os = Environment.OSVersion;

Windows\Win32\PInvokeCore.GetClassLong.cs (1)

18=> Environment.Is64BitProcess

Windows\Win32\PInvokeCore.GetWindowLong.cs (1)

28nint result = Environment.Is64BitProcess

Windows\Win32\PInvokeCore.SetClassLong.cs (1)

16=> Environment.Is64BitProcess

Windows\Win32\PInvokeCore.SetWindowLong.cs (1)

17nint result = Environment.Is64BitProcess

Microsoft.TemplateEngine.Abstractions (1)

IEnvironment.cs (1)

22/// Replaces the name of each environment variable embedded in the specified string with the string equivalent of the value of the variable, then returns the resulting string. Equivalent to <see cref="Environment.ExpandEnvironmentVariables(string)"/>.

Microsoft.TemplateEngine.Cli (7)

CliEnvironment.cs (3)

19var env = Environment.GetEnvironmentVariables(); 29public string NewLine { get; } = Environment.NewLine; 39return Environment.ExpandEnvironmentVariables(name);

Commands\create\TemplateCommand.cs (1)

41template.Name + Environment.NewLine + template.Description)

TemplatePackageDisplay.cs (3)

382reporter.Write(Environment.NewLine); 388Environment.NewLine, 390reporter.Write(Environment.NewLine);

Microsoft.TemplateEngine.Core (1)

Expressions\Shared\SharedEvaluatorDefinition.cs (1)

194: (faultedMessage + Environment.NewLine + e.Message);

Microsoft.TemplateEngine.Edge (8)

DefaultEnvironment.cs (4)

11/// Gets environment variables from <see cref="Environment"/>. 24NewLine = Environment.NewLine; 38return Environment.ExpandEnvironmentVariables(name); 57IDictionary env = Environment.GetEnvironmentVariables();

DefaultTemplateEngineHost.cs (1)

37WorkingDirectory = Environment.CurrentDirectory;

Settings\TemplateCache.cs (1)

280templatesList.ToString().TrimEnd(Environment.NewLine.ToCharArray()),

Template\TemplateCreator.cs (1)

220string message = string.Join(Environment.NewLine, ExceptionMessages(cx));

VirtualEnvironment.cs (1)

19/// <param name="includeRealEnvironment">If set to true - variables from <see cref="Environment"/> are added.</param>

Microsoft.TestPlatform.Build (8)

Tasks\TestTaskUtils.cs (2)

236Environment.SetEnvironmentVariable("VSTEST_MSBUILD_NOLOGO", "1"); 402var dotnetHostPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH");

Tasks\VSTestLogsTask.cs (1)

25Log.LogMessage(MessageImportance.Normal, Resources.Resources.BuildCompleted + Environment.NewLine);

Tasks\VSTestTask.cs (2)

48var traceEnabledValue = Environment.GetEnvironmentVariable("VSTEST_BUILD_TRACE"); 51var debugEnabled = Environment.GetEnvironmentVariable("VSTEST_BUILD_DEBUG");

Tasks\VSTestTask2.cs (3)

61_disableUtf8ConsoleEncoding = Environment.GetEnvironmentVariable("VSTEST_DISABLE_UTF8_CONSOLE_ENCODING") == "1"; 62var isPrependedWithAnsi = Environment.GetEnvironmentVariable("DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION"); 167var n = Environment.NewLine;

Microsoft.TestPlatform.CommunicationUtilities (1)

DataCollectionRequestHandler.cs (1)

276Path.GetFullPath(Environment.ExpandEnvironmentVariables(datacollectorSearchPath));

Microsoft.TestPlatform.CoreUtilities (11)

Extensions\StringBuilderExtensions.cs (1)

31data += Environment.NewLine;

FeatureFlag\FeatureFlag.cs (1)

108var environmentValue = Environment.GetEnvironmentVariable(featureFlag)?.Trim();

Helpers\DotnetHostHelper.cs (1)

113var pathString = Environment.GetEnvironmentVariable("PATH")!;

Helpers\EnvironmentHelper.cs (1)

20var envVarValue = Environment.GetEnvironmentVariable(VstestConnectionTimeout);

Helpers\EnvironmentVariableHelper.cs (4)

15=> Environment.GetEnvironmentVariable(variable); 19=> Environment.GetEnvironmentVariable(variable) is string value && !string.IsNullOrEmpty(value) 25=> Environment.SetEnvironmentVariable(variable, value); 29=> Environment.GetEnvironmentVariables();

Output\ConsoleOutput.cs (1)

58Write(Environment.NewLine, level);

Tracing\EqtTrace.cs (2)

732string prefix = Environment.NewLine + '\t'; 788message.Append(Environment.NewLine);

Microsoft.TestPlatform.CrossPlatEngine (13)

Adapter\FrameworkHandle.cs (1)

93WorkingDirectory = workingDirectory ?? Environment.CurrentDirectory

Client\ProxyOperationManager.cs (4)

258var hostDebugEnabled = Environment.GetEnvironmentVariable("VSTEST_HOST_DEBUG"); 259var nativeHostDebugEnabled = Environment.GetEnvironmentVariable("VSTEST_HOST_NATIVE_DEBUG"); 330var timeout = int.TryParse(Environment.GetEnvironmentVariable("VSTEST_TESTHOST_SHUTDOWN_TIMEOUT"), out var time) 577(true, true) => $"Process path: {processFileName}{Environment.NewLine}{stdError}",

DataCollection\InProcDataCollector.cs (1)

158assembly = _assemblyLoadContext.LoadAssemblyFromPath(Environment.ExpandEnvironmentVariables(codeBase));

DataCollection\ProxyDataCollectionManager.cs (1)

267var dataCollectorDebugEnabled = Environment.GetEnvironmentVariable(DebugEnvironmentVaribleName);

EventHandlers\TestRequestHandler.cs (3)

116var remotePath = Environment.GetEnvironmentVariable("VSTEST_UWP_DEPLOY_REMOTE_PATH") ?? self.RemotePath ?? currentProcessDirectory; 118var localPath = Environment.GetEnvironmentVariable("VSTEST_UWP_DEPLOY_LOCAL_PATH") ?? self.LocalPath; 354var flag = Environment.GetEnvironmentVariable("VSTEST_DISABLE_PROTOCOL_3_VERSION_DOWNGRADE");

Execution\BaseRunTests.cs (1)

423var pid = Environment.ProcessId;

PostProcessing\ArtifactProcessingManager.cs (2)

70var pid = Environment.ProcessId; 252private static bool IsTelemetryOptedIn() => Environment.GetEnvironmentVariable("VSTEST_TELEMETRY_OPTEDIN")?.Equals("1", StringComparison.Ordinal) == true;

Microsoft.TestPlatform.Extensions.BlameDataCollector (14)

BlameCollector.cs (3)

713var temp = Environment.GetEnvironmentVariable("VSTEST_DUMP_TEMP_PATH") ?? Environment.GetEnvironmentVariable("AGENT_TEMPDIRECTORY") ?? Path.GetTempPath(); 730var dumpDirectoryOverride = Environment.GetEnvironmentVariable("VSTEST_DUMP_PATH");

BlameLogger.cs (1)

103sb.Append(tcn).Append(Environment.NewLine);

CrashDumperFactory.cs (1)

43var procdumpOverride = Environment.GetEnvironmentVariable("VSTEST_DUMP_FORCEPROCDUMP")?.Trim();

HangDumperFactory.cs (1)

21var procdumpOverride = Environment.GetEnvironmentVariable("VSTEST_DUMP_FORCEPROCDUMP")?.Trim();

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

Microsoft.TestPlatform.PlatformAbstractions (7)

common\Tracing\PlatformEqtTrace.cs (2)

226Environment.CurrentManagedThreadId, 394string[] args = Environment.GetCommandLineArgs();

Interfaces\System\IEnvironment.cs (1)

38/// <inheritdoc cref="System.Environment.ProcessorCount"/>

net462\System\ProcessHelper.cs (1)

107if (!Environment.Is64BitOperatingSystem)

netcore\System\PlatformEnvironment.cs (3)

63public int ProcessorCount => Environment.ProcessorCount; 68Environment.Exit(exitcode); 73=> Environment.CurrentManagedThreadId;

Microsoft.TestPlatform.TestHostRuntimeProvider (1)

Hosting\DotnetTestHostManager.cs (1)

648string? processorArchitecture = Environment.GetEnvironmentVariable(PROCESSOR_ARCHITECTURE, EnvironmentVariableTarget.Machine);

Microsoft.TestPlatform.Utilities (2)

ClientUtilities.cs (1)

65fileName = Environment.ExpandEnvironmentVariables(fileName);

InferRunSettingsHelper.cs (1)

725&& (targetPlatform == Architecture.X64 && !Environment.Is64BitOperatingSystem || sourcePlatform != targetPlatform);

Microsoft.TestPlatform.VsTestConsole.TranslationLayer (3)

ConsoleParameters.cs (1)

52/// You most likely want to use <see cref="System.Environment.GetEnvironmentVariables(System.EnvironmentVariableTarget)"/> and combine

VsTestConsoleWrapper.cs (2)

172_consoleParameters.ParentProcessId = Environment.ProcessId; 599_consoleParameters.ParentProcessId = Environment.ProcessId;

Microsoft.VisualBasic.Forms (14)

Microsoft\VisualBasic\ApplicationServices\ApplicationBase.vb (2)

102''' Returns the value of the specified <see cref="Environment"/> variable. 111Dim variableValue As String = Environment.GetEnvironmentVariable(name)

Microsoft\VisualBasic\ApplicationServices\AssemblyInfo.vb (2)

197Return Environment.StackTrace 271Return Environment.WorkingSet

Microsoft\VisualBasic\ApplicationServices\ConsoleApplicationBase.vb (2)

46''' This function differs from <see cref="Environment.GetCommandLineArgs"/> 54Dim envArgs As String() = Environment.GetCommandLineArgs

Microsoft\VisualBasic\Devices\Clock.vb (1)

44Return Environment.TickCount

Microsoft\VisualBasic\Devices\ComputerInfo.vb (2)

106Return Environment.OSVersion.Platform.ToString 120Return Environment.OSVersion.Version.ToString

Microsoft\VisualBasic\Devices\Network.DownloadFile.vb (1)

371AndAlso Environment.UserInteractive _

Microsoft\VisualBasic\Devices\NetworkUtilities.vb (1)

107Return showUI AndAlso Environment.UserInteractive

Microsoft\VisualBasic\Devices\ServerComputer.vb (2)

80''' This property wraps the <see cref="Environment.MachineName"/> property 86Return Environment.MachineName

Microsoft\VisualBasic\Logging\FileLogTraceListener.vb (1)

101_hostName = Environment.MachineName

Microsoft.VisualStudio.TestPlatform.Client (1)

TestPlatform.cs (1)

314string adapterPath = Path.GetFullPath(Environment.ExpandEnvironmentVariables(path));

Microsoft.VisualStudio.TestPlatform.Common (10)

DataCollection\DataCollectionAttachmentManager.cs (1)

113var expandedOutputDirectory = Environment.ExpandEnvironmentVariables(outputDirectory);

DataCollection\TestPlatformDataCollectionLogger.cs (4)

73"Data collector '{0}' logged the following error:" + Environment.NewLine + 74"Description: {1}" + Environment.NewLine + 75"Exception type: {2}" + Environment.NewLine + "Exception message: {3}" 76+ Environment.NewLine + "Exception stack trace: {4}",

ExtensionFramework\TestPluginCache.cs (4)

91"TestPluginCache.GetExtensionPaths: Filtered extension paths: {0}", string.Join(Environment.NewLine, extensions)); 97"TestPluginCache.GetExtensionPaths: Added default extension paths: {0}", string.Join(Environment.NewLine, _defaultExtensionPaths)); 101"TestPluginCache.GetExtensionPaths: Added unfilterableExtensionPaths: {0}", string.Join(Environment.NewLine, _unfilterableExtensionPaths)); 151"TestPluginCache.DiscoverTestExtensions: Discovering the extensions using allExtensionPaths: {0}", string.Join(Environment.NewLine, allExtensionPaths));

Utilities\RunSettingsUtilities.cs (1)

45return Environment.ExpandEnvironmentVariables(runConfiguration.ResultsDirectory);

Microsoft.VisualStudio.TestPlatform.Extensions.Html.TestLogger (2)

HtmlLogger.cs (2)

312Environment.GetEnvironmentVariable("UserName"), Environment.MachineName,

Microsoft.VisualStudio.TestPlatform.Extensions.Trx.TestLogger (12)

ObjectModel\TestRun.cs (2)

64_name = string.Format(CultureInfo.CurrentCulture, TrxLoggerResources.Common_TestRunName, Environment.GetEnvironmentVariable("UserName"), Environment.MachineName, FormatDateTimeForRunName(DateTime.Now));

TrxLogger.cs (3)

295runMessage = new RunInfo(e.Message, null, Environment.MachineName, TrxLoggerObjectModel.TestOutcome.Warning); 304runMessage = new RunInfo(e.Message, null, Environment.MachineName, TrxLoggerObjectModel.TestOutcome.Error); 455RunInfo runMessage = new(msg, null, Environment.MachineName, TrxLoggerObjectModel.TestOutcome.Error);

Utility\Converter.cs (7)

449targetDirectory = Path.Combine(targetDirectory, Environment.MachineName); 474string fileName = Path.Combine(Environment.MachineName, Path.GetFileName(targetFileName)); 490Environment.MachineName, 505testResultDirectory = Path.Combine(testResultDirectory, Environment.MachineName); 529string fileName = Path.Combine(Environment.MachineName, Path.GetFileName(targetFileName)); 689new TestResultAggregation(runId, testId, executionId, parentExecutionId, resultName, Environment.MachineName, outcome, testType, testCategoryId, _trxFileHelper) : 690new UnitTestResult(runId, testId, executionId, parentExecutionId, resultName, Environment.MachineName, outcome, testType, testCategoryId, _trxFileHelper);

Microsoft.VisualStudio.TestPlatform.ObjectModel (4)

DataCollector\TransferInformation\FileTransferInformation.cs (1)

58path = Environment.ExpandEnvironmentVariables(path);

RunSettings\RunConfiguration.cs (2)

908solutionDirectory = Environment.ExpandEnvironmentVariables(solutionDirectory); 958dotnetHostPath = Environment.ExpandEnvironmentVariables(dotnetHostPath);

Utilities\StringUtilities.cs (1)

27result = result.TrimEnd(Environment.NewLine.ToCharArray());

Microsoft.Win32.Registry (1)

Microsoft\Win32\RegistryKey.cs (1)

1178str = Environment.ExpandEnvironmentVariables(str);

MSBuild (40)

CommandLine\CommandLineParser.cs (1)

392argsFromResponseFile.AddRange(QuotingUtilities.SplitUnquoted(Environment.ExpandEnvironmentVariables(responseFileLine)));

CommandLine\CommandLineSwitchException.cs (1)

75return base.Message + Environment.NewLine + ResourceUtilities.FormatResourceStringStripCodeAndKeyword("InvalidSwitchIndicator", commandLineArg);

InitializationException.cs (3)

81return base.Message + Environment.NewLine + ResourceUtilities.FormatResourceStringStripCodeAndKeyword("InvalidSwitchIndicator", invalidSwitch); 150errorMessage += Environment.NewLine + e.ToString(); 177errorMessage += Environment.NewLine + e.ToString();

OutOfProcTaskHostNode.cs (2)

1183context.SavedCurrentDirectory = Environment.CurrentDirectory; 1365if (Environment.GetEnvironmentVariable("MSBUILDTASKHOSTABORTTASKONCANCEL") == "1")

parent\Shared\LogMessagePacketBase.cs (2)

269private static readonly int s_defaultPacketVersion = (Environment.Version.Major * 10) + Environment.Version.Minor;

PerformanceLogEventListener.cs (2)

55string logDirectory = Environment.GetEnvironmentVariable(PerfLogDirEnvVar); 145s_builder.Append($"[{DateTime.UtcNow:o}] Event={eventData.EventSource.Name}/{eventData.EventName} ProcessID={_processIDStr} ThreadID={Environment.CurrentManagedThreadId}\t ");

src\msbuild\src\Shared\Debugging\DebugUtils.cs (3)

178builder.Append(Environment.NewLine); 181builder.Append(Environment.NewLine); 183builder.Append(Environment.NewLine);

XMake.cs (26)

MSBuild.Coordinator (2)

CoordinatorServer.DefaultDebugOutput.cs (2)

75? $"TID {Environment.CurrentManagedThreadId}" 76: $"{threadName} (TID {Environment.CurrentManagedThreadId})";

mscorlib (1)

parent\ref\mscorlib.cs (1)

223[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Environment))]

MyFrontend (1)

Program.cs (1)

13var isHttps = Environment.GetEnvironmentVariable("DOTNET_LAUNCHPROFILE") == "https";

netstandard (1)

netstandard.cs (1)

781[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Environment))]

NuGet.Build.Tasks (3)

BuildTasksUtility.cs (1)

219DisableParallel = Environment.ProcessorCount == 1 ? true : disableParallel,

RestoreTaskEx.cs (1)

40public bool DisableParallel { get; set; } = Environment.ProcessorCount == 1;

StaticGraphRestoreTaskBase.cs (1)

134WorkingDirectory = Environment.CurrentDirectory,

NuGet.Build.Tasks.Console (9)

MSBuildFeatureFlags.cs (8)

MSBuildStaticGraphRestore.cs (1)

991Parallel.ForEach(projects, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, project =>

NuGet.CommandLine.XPlat (14)

Commands\ConfigCommands\ConfigRunners.cs (2)

221logger.LogMinimal(Environment.NewLine); 230logger.LogMinimal(Environment.NewLine);

Commands\Package\Update\PackageUpdateCommand.cs (1)

60Project = project?.FullName ?? Environment.CurrentDirectory,

Commands\Package\Update\PackageUpdateCommandRunner.cs (1)

432MaxDegreeOfParallelism = Environment.ProcessorCount,

Commands\PackageReferenceCommands\AddPackageReferenceCommandRunner.cs (1)

129sources.Add(UriUtility.GetAbsolutePath(Environment.CurrentDirectory, source));

Commands\PackageReferenceCommands\ListPackage\ListPackageCommandRunner.cs (2)

434? Environment.ProcessorCount + 1 // Fallback when no package sources are configured 435: (Environment.ProcessorCount / listPackageArgs.PackageSources.Count) + 1;

Commands\Why\DotnetVersionChecker.cs (1)

20_cachedVersion = Environment.Version.Major;

UILanguageOverride.cs (1)

90Environment.SetEnvironmentVariable(environmentVariableName, value);

Utility\AddPackageCommandUtility.cs (1)

33var maxTasks = Environment.ProcessorCount;

Utility\HttpSourcesUtility.cs (2)

55Environment.NewLine + string.Join(Environment.NewLine, httpSources.Select(e => e.Name)));

Utility\MSBuildAPIUtility.cs (1)

678Environment.NewLine,

Utility\TableParser.cs (1)

137stringTable.Add(new FormattedCell(Environment.NewLine));

NuGet.Commands (26)

ListCommand\ListCommandRunner.cs (2)

100Environment.NewLine + string.Join(Environment.NewLine, httpPackageSources.Select(e => e.Name))));

RestoreCommand\CompatibilityIssue.cs (2)

218sb.Append(Environment.NewLine).Append(" - " + framework); 237sb.Append(Environment.NewLine).Append(" - " + framework);

RestoreCommand\Diagnostics\DiagnosticUtility.cs (1)

97sb.Append(Environment.NewLine);

RestoreCommand\RequestFactory\DependencyGraphSpecRequestProvider.cs (1)

91MaxDegreeOfParallelism = Environment.ProcessorCount

RestoreCommand\RestoreCommand.cs (8)

1653var invalidReasons = string.Join(Environment.NewLine, lockFileResult.InvalidReasons); 1856var text = Strings.Log_CycleDetected + $" {Environment.NewLine} {cycle.GetPath()}."; 1888+ $" {Environment.NewLine} {versionConflict.Selected.GetPathWithLastRange()} {Environment.NewLine} {versionConflict.Conflicting.GetPathWithLastRange()}."; 1898+ $" {Environment.NewLine} {versionConflict.Selected.GetPathWithLastRange()} {Environment.NewLine} {versionConflict.Conflicting.GetPathWithLastRange()}."; 1949+ $" {Environment.NewLine} {downgraded.GetPathWithLastRange()} {Environment.NewLine} {downgradedBy.GetPathWithLastRange()}";

RestoreCommand\RestoreRunner.cs (1)

230maxTasks = Environment.ProcessorCount;

SignCommand\SignCommandRunner.cs (1)

54signArgs.Logger.LogInformation(Environment.NewLine);

SourcesCommands\SourceRunners.cs (2)

230Environment.NewLine + string.Join(Environment.NewLine, httpPackageSources.Select(e => e.Name))));

src\nuget-client\build\Shared\TaskResultCache.cs (2)

46_cache = new(concurrencyLevel: Environment.ProcessorCount, capacity); 47_perTaskLock = new(concurrencyLevel: Environment.ProcessorCount, capacity);

TrustedSignersCommand\TrustedSignersCommandRunner.cs (1)

214await logger.LogAsync(LogLevel.Minimal, Environment.NewLine);

VerifyCommand\VerifyCommandRunner.cs (5)

121logger.LogMinimal(Environment.NewLine + string.Format(CultureInfo.CurrentCulture, 128logger.LogInformation($"{packagePath}{Environment.NewLine}"); 137logger.LogMinimal(Environment.NewLine); 154logger.LogInformation(Environment.NewLine + string.Format(CultureInfo.CurrentCulture, Strings.VerifyCommand_Success, packageIdentity.ToString())); 158logger.LogMinimal(Environment.NewLine + Strings.VerifyCommand_Failed);

NuGet.Common (15)

EnvironmentVariableWrapper.cs (1)

18return Environment.GetEnvironmentVariable(variable);

Migrations\Migration1.cs (6)

61var homePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 106var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 117var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

Migrations\MigrationRunner.cs (4)

92return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Migrations"); 98? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "share", "NuGet", "Migrations")

PathUtil\NuGetEnvironment.cs (4)

69RuntimeEnvironmentHelper.IsLinux ? "NuGetScratch" + Environment.UserName : "NuGetScratch"); 312return EnvironmentVariableReader.GetEnvironmentVariable(DotNetHome) ?? Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); 409/// Since <see cref="Environment.SpecialFolder"/> is not available on .NET Core, we have to

NuGet.Configuration (3)

Settings\Settings.cs (1)

698return Environment.ExpandEnvironmentVariables(value);

Utility\XElementUtility.cs (2)

31var parentIndent = leadingText != null ? leadingText.Value : Environment.NewLine; 79var indentString = textBeforeOrNull.Value.Trim(Environment.NewLine.ToCharArray());

NuGet.DependencyResolver.Core (2)

src\nuget-client\build\Shared\TaskResultCache.cs (2)

46_cache = new(concurrencyLevel: Environment.ProcessorCount, capacity); 47_perTaskLock = new(concurrencyLevel: Environment.ProcessorCount, capacity);

NuGet.PackageManagement (8)

NuGetPackageManager.cs (5)

1108nuGetProjectContext.Log(MessageLevel.Info, Environment.NewLine); 1842nuGetProjectContext.Log(NuGet.ProjectManagement.MessageLevel.Info, Environment.NewLine); 2372nuGetProjectContext.Log(NuGet.ProjectManagement.MessageLevel.Info, Environment.NewLine); 2716$"{Environment.NewLine}{string.Join(Environment.NewLine, errors.Select(e => e.FormatWithCode()))}");

PackageManagementConstants.cs (1)

13public static readonly int DefaultMaxDegreeOfParallelism = Environment.ProcessorCount;

Utility\XElementExtensions.cs (2)

267var parentIndent = leadingText != null ? leadingText.Value : Environment.NewLine; 350var indentString = textBeforeOrNull.Value.Trim(Environment.NewLine.ToCharArray());

NuGet.Packaging (10)

PackageCreation\Authoring\Manifest.cs (1)

287string message = String.Join(Environment.NewLine, results);

PackageCreation\Authoring\PackageBuilder.cs (2)

973if (warningMessage.Length > Environment.NewLine.Length) 975warningMessage.Length -= Environment.NewLine.Length;

Signing\Signatures\AuthorPrimarySignature.cs (1)

32issues.Add(SignatureLog.MinimalLog(Environment.NewLine +

Signing\Signatures\RepositoryCountersignature.cs (1)

98issues.Add(SignatureLog.MinimalLog(Environment.NewLine +

Signing\Signatures\RepositoryPrimarySignature.cs (1)

37issues.Add(SignatureLog.MinimalLog(Environment.NewLine +

Signing\Signatures\Signature.cs (1)

159$"{Environment.NewLine}")));

Signing\Timestamp\Timestamp.cs (2)

131issues.Add(SignatureLog.InformationLog(string.Format(CultureInfo.CurrentCulture, Strings.TimestampValue, GeneralizedTime.LocalDateTime.ToString(CultureInfo.CurrentCulture)) + Environment.NewLine)); 136$"{Environment.NewLine}{CertificateUtility.X509Certificate2ToString(timestamperCertificate, fingerprintAlgorithm)}")));

StringFormatter.cs (1)

42return Strings.ZipFileTimeStampModifiedWarning + Environment.NewLine + listOfFileTimeStampModifiedMessages;

NuGet.Protocol (15)

HttpSource\HttpRetryHandler.cs (1)

289+ Environment.NewLine

HttpSource\HttpSource.cs (1)

112+ Environment.NewLine

NuGetTestMode.cs (1)

39var testMode = Environment.GetEnvironmentVariable(_testModeEnvironmentVariableName);

Plugins\Logging\MachineLogMessage.cs (1)

16_logicalProcessorCount = Environment.ProcessorCount;

Plugins\Logging\PluginLogger.cs (1)

85_logDirectoryPath = Environment.CurrentDirectory;

Providers\RepositorySignatureResourceProvider.cs (1)

141+ Environment.NewLine

Providers\ServiceIndexResourceV3Provider.cs (1)

170+ Environment.NewLine

RemoteRepositories\HttpFileSystemBasedFindPackageByIdResource.cs (1)

550+ Environment.NewLine

RemoteRepositories\RemoteV2FindPackageByIdResource.cs (1)

547+ Environment.NewLine

Resources\PackageUpdateResource.cs (1)

499+ Environment.NewLine

src\nuget-client\build\Shared\TaskResultCache.cs (2)

46_cache = new(concurrencyLevel: Environment.ProcessorCount, capacity); 47_perTaskLock = new(concurrencyLevel: Environment.ProcessorCount, capacity);

Utility\FindPackagesByIdNupkgDownloader.cs (2)

299+ Environment.NewLine 323+ Environment.NewLine

Utility\GetDownloadResultUtility.cs (1)

117+ Environment.NewLine

PresentationBuildTasks (2)

MS\Internal\Tasks\TaskHelper.cs (2)

52log.LogMessage(MessageImportance.Low,Environment.NewLine); 55log.LogMessage(MessageImportance.Low, Environment.NewLine);

PresentationCore (51)

MS\Internal\DpiUtil\DpiUtil+ProcessDpiAwarenessHelper.cs (1)

98windowThreadProcessId = Environment.ProcessId;

MS\Internal\FontCache\FamilyCollection.cs (1)

153OperatingSystem osInfo = Environment.OSVersion;

MS\Internal\FontCache\FontCacheUtil.cs (1)

302string s = Environment.GetEnvironmentVariable(WinDir) + @"\Fonts\";

System\Windows\Automation\Peers\AutomationPeer.cs (2)

1456return new int [] { 7, Environment.ProcessId, this.GetHashCode() }; 2484private static object GetCurrentProcessId(AutomationPeer peer) { return Environment.ProcessId; }

System\Windows\Diagnostics\VisualDiagnostics.cs (1)

225value = Environment.GetEnvironmentVariable(environmentVariable);

System\Windows\Input\KeyboardDevice.cs (1)

264int timeStamp = Environment.TickCount ;

System\Windows\Input\ManipulationLogic.cs (1)

414ManipulationStartingEventArgs starting = new ManipulationStartingEventArgs(_manipulationDevice, Environment.TickCount)

System\Windows\Input\MouseDevice.cs (3)

277int timeStamp = Environment.TickCount; 881int timeStamp = Environment.TickCount; 932int timeStamp = Environment.TickCount;

System\Windows\Input\Stylus\Common\DynamicRenderer.cs (1)

262Environment.TickCount, GetCurrentHostVisual());

System\Windows\Input\Stylus\Common\DynamicRendererThreadManager.cs (1)

240if (__inkingDispatcher != null && !Environment.HasShutdownStarted)

System\Windows\Input\Stylus\Common\MultiTouchSystemGestureLogic.cs (3)

63_firstDownTime = Environment.TickCount; 86_firstUpTime = Environment.TickCount; 185int now = Environment.TickCount;

System\Windows\Input\Stylus\Pointer\PointerInteractionEngine.cs (3)

312Environment.TickCount, 349Environment.TickCount, 442Environment.TickCount,

System\Windows\Input\Stylus\Pointer\PointerStylusDevice.cs (4)

528int timeStamp = Environment.TickCount; 626int timeStamp = Environment.TickCount; 787_lastEventTimeTicks = Environment.TickCount; 839Environment.TickCount,

System\Windows\Input\Stylus\Wisp\PenThreadWorker.cs (8)

151Debug.WriteLine("WorkerOperationGetTabletsInfo.OnDoWork failed due to: {0}{1}", Environment.NewLine, e.ToString()); 198result.CommHandle = Environment.Is64BitProcess ? (nint)commHandle : (int)commHandle; 207Debug.WriteLine("WorkerOperationCreateContext.OnDoWork failed due to a {0}{1}", Environment.NewLine, e.ToString()); 314Debug.WriteLine("WorkerOperationRefreshCursorInfo.OnDoWork failed due to a {0}{1}", Environment.NewLine, e.ToString()); 356Debug.WriteLine("WorkerOperationGetTabletInfo.OnDoWork failed due to {0}{1}", Environment.NewLine, e.ToString()); 396Debug.WriteLine("WorkerOperationWorkerGetUpdatedSizes.OnDoWork failed due to a {0}{1}", Environment.NewLine, e.ToString()); 799int timestamp = Environment.TickCount; 1252penContext.FirePenOutOfRange(0, Environment.TickCount);

System\Windows\Input\Stylus\Wisp\WispLogic.cs (3)

917_lastInRangeTime = Environment.TickCount; 1007_lastInRangeTime = Environment.TickCount; 1012_lastInRangeTime = Environment.TickCount;

System\Windows\Input\Stylus\Wisp\WispStylusDevice.cs (2)

223int timeStamp = Environment.TickCount; 334int timeStamp = Environment.TickCount;

System\Windows\Input\Stylus\Wisp\WispTabletDeviceCollection.cs (1)

82bool runningOnVista = (Environment.OSVersion.Version.Major >= VistaMajorVersion);

System\Windows\Input\TextCompositionEventArgs.cs (1)

27public TextCompositionEventArgs(InputDevice inputDevice, TextComposition composition) : base(inputDevice, Environment.TickCount)

System\Windows\Input\TextServicesContext.cs (1)

110if (!appDomainShutdown || System.Environment.OSVersion.Version.Major >= 6)

System\Windows\Input\Touch.cs (1)

40TouchFrameEventArgs args = new TouchFrameEventArgs(Environment.TickCount);

System\Windows\Input\TouchDevice.cs (1)

939TouchEventArgs touchEventArgs = new TouchEventArgs(this, Environment.TickCount)

System\Windows\InterOp\HwndPointerInputProvider.cs (5)

410handled = ProcessMessage(GetPointerId(wParam), RawStylusActions.InRange, Environment.TickCount); 415handled = ProcessMessage(GetPointerId(wParam), RawStylusActions.Move, Environment.TickCount); 420handled = ProcessMessage(GetPointerId(wParam), RawStylusActions.Down, Environment.TickCount); 425handled = ProcessMessage(GetPointerId(wParam), RawStylusActions.Up, Environment.TickCount); 433handled = ProcessMessage(GetPointerId(wParam), RawStylusActions.OutOfRange, Environment.TickCount);

System\Windows\InterOp\HwndTarget.cs (1)

529else if (processId != Environment.ProcessId)

System\Windows\Interop\OperatingSystemVersionCheck.cs (1)

49OperatingSystem os = Environment.OSVersion;

System\Windows\Media\MediaContext.cs (1)

173!Environment.UserInteractive ? // IF DisplayDevicesNotAvailable && IsNonInteractiveWindowStation/IsService...

System\Windows\MouseOverProperty.cs (1)

46MouseEventArgs mouseEventArgs = new MouseEventArgs(Mouse.PrimaryDevice, Environment.TickCount, Mouse.PrimaryDevice.StylusDevice)

System\Windows\StylusOverProperty.cs (1)

38StylusEventArgs stylusEventArgs = new StylusEventArgs(Stylus.CurrentStylusDevice, Environment.TickCount)

PresentationFramework (23)

Microsoft\Win32\CommonDialog.cs (2)

57if (!Environment.UserInteractive) 128if (!Environment.UserInteractive)

System\Windows\Application.cs (1)

2189System.Environment.ExitCode = exitCode;

System\Windows\Controls\ScrollViewer.cs (2)

1766_panningInfo.InertiaBoundaryBeginTimestamp = Environment.TickCount; 1841if (Math.Abs(Environment.TickCount - _panningInfo.InertiaBoundaryBeginTimestamp) < PanningInfo.InertiaBoundryMinimumTicks)

System\Windows\Controls\VirtualizingStackPanel.cs (2)

9077int totalMilliseconds = Environment.TickCount - startTickCount; 9387int startMilliseconds = Environment.TickCount;

System\Windows\Controls\WebBrowser.cs (1)

751Version osver = Environment.OSVersion.Version;

System\windows\Documents\TextEditor.cs (1)

1225int endOfFirstLine = textData.IndexOf(Environment.NewLine, StringComparison.Ordinal);

System\windows\Documents\TextEditorTyping.cs (2)

1134string filteredText = This._FilterText(Environment.NewLine, This.Selection); 1138This.Selection.Text = Environment.NewLine;

System\Windows\Documents\TextFindEngine.cs (1)

473if (System.Environment.OSVersion.Version.Major >= 6)

System\Windows\Documents\TextRangeBase.cs (4)

694textBuffer.Append(Environment.NewLine); 715textBuffer.Append(Environment.NewLine); 781textBuffer.Append(Environment.NewLine); 787textBuffer.Append(Environment.NewLine);

System\Windows\Documents\TextServicesHost.cs (1)

372if (_thread == Thread.CurrentThread || System.Environment.OSVersion.Version.Major >= 6)

System\Windows\Documents\TextStore.cs (2)

1491if (!(nextChars[0] == Environment.NewLine[0] && nextChars[1] == Environment.NewLine[1]))

System\Windows\Interop\HwndHost.cs (1)

1043(idWindowProcess == Environment.ProcessId))

System\Windows\Standard\Utilities.cs (1)

22private static readonly Version _osVersion = Environment.OSVersion.Version;

System\Windows\StartupEventArgs.cs (1)

55string[] args = Environment.GetCommandLineArgs();

System\Windows\SystemParameters.cs (1)

1183if (System.Environment.OSVersion.Version.Major >= 6)

PresentationUI (2)

MS\Internal\Documents\RightsManagementManager.cs (2)

856string systemPath = Environment.GetFolderPath(Environment.SpecialFolder.System);

PromptAgentChat (2)

Program.cs (2)

29var projectEndpoint = Environment.GetEnvironmentVariable($"{environmentPrefix}_PROJECTENDPOINT") 31var agentName = Environment.GetEnvironmentVariable($"{environmentPrefix}_AGENTNAME")

RepoTasks (19)

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

1042return string.Join(Environment.NewLine, description);

src\aspnetcore\src\Shared\CertificateGeneration\MacOSCertificateManager.cs (4)

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

Roslyn.Diagnostics.Analyzers (27)

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

99var parentPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

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

61if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER"))) 71Environment.FailFast(message);

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

58if (Environment.OSVersion.Platform == PlatformID.Win32NT)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (3)

src\roslyn\src\Dependencies\Contracts\ErrorReporting\FailFast.cs (3)

44Environment.FailFast(exception.ToString(), exception); 54Environment.FailFast(message); 112Fail("ASSERT FAILED" + Environment.NewLine + message);

src\roslyn\src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

80: this(factory, Environment.ProcessorCount * 2, trimOnFree, trackLeaks

src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (5)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

173foreach (var line in child.ToString().Split([Environment.NewLine], StringSplitOptions.RemoveEmptyEntries))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingOptions2.cs (1)

47_ => Environment.NewLine

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\LineFormattingOptions.cs (1)

19[DataMember] public string NewLine { get; init; } = Environment.NewLine;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\RoslynTelemetry_LogBlock.cs (3)

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

285: reason + Environment.NewLine + restString;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\NonReentrantLock.cs (3)

Roslyn.Diagnostics.CSharp.Analyzers (1)

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

91var newLine = Environment.NewLine;

rzc (28)

ConnectionHost.cs (1)

63if (Environment.Is64BitProcess || Memory.IsMemoryAvailable())

DebugMode.cs (1)

16Console.WriteLine("Waiting for debugger in pid: {0}", Environment.ProcessId);

DefaultRequestDispatcher.cs (1)

341var response = new ShutdownServerResponse(Environment.ProcessId);

DiscoverCommand.cs (1)

66ProjectDirectory.Values.Add(Environment.CurrentDirectory);

GenerateCommand.cs (1)

146ProjectDirectory.Values.Add(Environment.CurrentDirectory);

Json\Assumed.cs (2)

151=> ThrowHelper.ThrowInvalidOperationException(message + Environment.NewLine + Strings.FormatFile_0_Line_1(path, line)); 156=> ThrowHelper.ThrowInvalidOperationException<T>(message + Environment.NewLine + Strings.FormatFile_0_Line_1(path, line));

PipeName.cs (1)

34var userName = Environment.UserName;

ServerCommand.cs (5)

147var processId = Environment.ProcessId; 159var content = $"{processId}{Environment.NewLine}rzc{Environment.NewLine}{rzcPath}{Environment.NewLine}{Pipe.Value()}"; 169var path = Environment.GetEnvironmentVariable("DOTNET_BUILD_PIDFILE_DIRECTORY");

ServerProtocol\ServerConnection.cs (8)

ServerProtocol\ServerLogger.cs (4)

src\sdk\src\Common\CliFolderPathCalculatorCore.cs (3)

17: this(Environment.GetEnvironmentVariable) 59home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);

sdk-tasks (2)

EnvironmentVariableFilter.cs (1)

36var allEnvironmentVariableNames = Environment

IncrementalLayout.cs (1)

205CompletionMarker + Environment.NewLine);

Security.TransportSecurity.IntegrationTests (4)

Negotiate\NegotiateStream_Http_Tests.4.1.0.cs (1)

84if (Environment.Version.Major == 5 && !OSID.AnyWindows.MatchesCurrent() && !TestProperties.GetProperty(TestProperties.ServiceUri_PropertyName).Contains("/"))

Tcp\ClientCredentialTypeCertificateCanonicalNameTests.4.1.0.cs (3)

87errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message); 164errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message); 248errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message);

SelectTests (6)

Program.cs (5)

358var githubOutput = Environment.GetEnvironmentVariable("GITHUB_OUTPUT"); 554var summaryPath = Environment.GetEnvironmentVariable("GITHUB_STEP_SUMMARY"); 612var jsonPath = Environment.GetEnvironmentVariable("SELECT_TESTS_JSON_FILE"); 725var commentPath = Environment.GetEnvironmentVariable("SELECT_TESTS_COMMENT_FILE"); 1257var summaryPath = Environment.GetEnvironmentVariable("GITHUB_STEP_SUMMARY");

SelectionTrace.cs (1)

26_verbose = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("SELECTTESTS_TRACE"));

Shared.Tests (1)

JsonSchemaExporter\SchemaTestHelpers.cs (1)

47{string.Join(Environment.NewLine, errors)}

Stress.ApiService (3)

Program.cs (3)

167var urls = Environment.GetEnvironmentVariable("ASPNETCORE_URLS")!.Split(';'); 271new KeyValuePair<string, object?>("Tid", Environment.CurrentManagedThreadId), 272new KeyValuePair<string, object?>("Pid", Environment.ProcessId),

Stress.AppHost (6)

AppHost.cs (4)

19var manualArgSource = builder.AddExecutable("manual-arg-source", "dotnet", Environment.CurrentDirectory) 128builder.AddExecutable("executableWithSingleArg", "dotnet", Environment.CurrentDirectory, "--version"); 129builder.AddExecutable("executableWithSingleEscapedArg", "dotnet", Environment.CurrentDirectory, "one two"); 130builder.AddExecutable("executableWithMultipleArgs", "dotnet", Environment.CurrentDirectory, "--version", "one two");

CommandResources.cs (2)

23private static string NodeExecutablePath { get; } = Environment.GetEnvironmentVariable("NODE") ?? "node"; 24private static string DotnetExecutablePath { get; } = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") ?? "dotnet";

SuperFileCheck (4)

Program.cs (4)

366return String.Join(Environment.NewLine, methodDecl.GetText().Lines.Select(x => TransformLine(x, checkPrefixes))); 552Console.Write(Environment.NewLine); 555Console.Write(Environment.NewLine); 557Console.Write(Environment.NewLine);

System.CodeDom (4)

Microsoft\CSharp\CSharpCodeGenerator.cs (1)

151b.Append(Environment.NewLine);

Microsoft\VisualBasic\VBCodeGenerator.cs (1)

364b.Append(Environment.NewLine);

System\CodeDom\Compiler\Executor.cs (2)

25ExecWaitWithCapture(userToken, cmd, Environment.CurrentDirectory, tempFiles, ref outputName, ref errorName); 31ExecWaitWithCapture(IntPtr.Zero, cmd, Environment.CurrentDirectory, tempFiles, ref outputName, ref errorName);

System.Collections.Concurrent (12)

System\Collections\Concurrent\BlockingCollection.cs (3)

954startTime = unchecked((uint)Environment.TickCount); 1099uint elapsedMilliseconds = unchecked((uint)Environment.TickCount - startTime); 1356startTime = unchecked((uint)Environment.TickCount);

System\Collections\Concurrent\ConcurrentBag.cs (6)

154int currentThreadId = Environment.CurrentManagedThreadId; 693_ownerThreadId = Environment.CurrentManagedThreadId; 718Debug.Assert(Environment.CurrentManagedThreadId == _ownerThreadId); 838Debug.Assert(Environment.CurrentManagedThreadId == _ownerThreadId); 855Debug.Assert(Environment.CurrentManagedThreadId == _ownerThreadId); 930Debug.Assert(Environment.CurrentManagedThreadId == _ownerThreadId);

System\Collections\Concurrent\PartitionerStatic.cs (3)

186long rangeSize = (long)(range / (Environment.ProcessorCount * CoreOversubscriptionRate)); 240int rangeSize = (int)(range / (Environment.ProcessorCount * CoreOversubscriptionRate)); 581int fillBufferMultiplier = (Environment.ProcessorCount > 4) ? 4 : 1;

System.CommandLine (9)

Completions\CompletionAction.cs (1)

37Environment.NewLine,

EnvironmentVariablesDirective.cs (1)

64Environment.SetEnvironmentVariable(variable.ToString(), value);

LocalizationResources.cs (4)

223value, commandAlias, expectedType, Environment.NewLine + string.Join(Environment.NewLine, completions)); 236value, optionAlias, expectedType, Environment.NewLine + string.Join(Environment.NewLine, completions));

RootCommand.cs (3)

74/// <item><description>The <c>System.CommandLine.ExecutableName</c> value read from <see cref="AppContext"/>, when there is no managed entry point (<see cref="Assembly.GetEntryAssembly"/> returns <see langword="null"/>) - most notably when hosted as a NativeAOT native library. In that case <see cref="Environment.GetCommandLineArgs"/> reflects the host process rather than this component. The value is emitted into the app's <c>runtimeconfig.json</c> by the <c>System.CommandLine</c> build targets and defaults to the assembly name.</description></item> 75/// <item><description>The file name (without extension) of the currently running executable, from <see cref="Environment.GetCommandLineArgs"/>.</description></item> 106var args = Environment.GetCommandLineArgs();

System.CommandLine.StaticCompletions (1)

ShellName.cs (1)

32var shellPath = Environment.GetEnvironmentVariable("SHELL") ?? throw new InvalidOperationException(Strings.ShellDiscovery_ShellEnvironmentNotSet);

System.Configuration.ConfigurationManager (4)

System\Configuration\ClientConfigPaths.cs (4)

155string roamingFolderPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); 162string localFolderPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

System.Console (7)

src\runtime\src\libraries\Common\src\System\Console\ConsoleUtils.cs (3)

src\runtime\src\libraries\Common\src\System\Text\EncodingHelper.Unix.cs (1)

39locale = Environment.GetEnvironmentVariable(envVar);

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\PersistedFiles.Unix.cs (1)

54string? userHomeDirectory = Environment.GetEnvironmentVariable("HOME");

System\TermInfo.DatabaseFactory.cs (2)

36=> Environment.GetEnvironmentVariable("TERMINFO"); 42string? term = Environment.GetEnvironmentVariable("TERM");

System.Data.Common (1)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

System.Data.Odbc (4)

src\runtime\src\libraries\Common\src\System\Data\ProviderBase\DbConnectionFactory.cs (1)

26private static readonly Task<DbConnectionInternal?>[] s_pendingOpenNonPooled = new Task<DbConnectionInternal?>[Environment.ProcessorCount];

System\Data\Odbc\OdbcConnection.cs (1)

568throw new DllNotFoundException(SR.Odbc_UnixOdbcNotFound + Environment.NewLine + e.Message);

System\Data\Odbc\OdbcException.cs (1)

23builder.Append(Environment.NewLine);

System\Data\Odbc\OdbcInfoMessageEvent.cs (1)

31if (0 < builder.Length) { builder.Append(Environment.NewLine); }

System.Data.OleDb (25)

OleDb_Util.cs (18)

OleDbConnectionInternal.cs (1)

72if (constr.PossiblePrompt && !System.Environment.UserInteractive)

OleDbException.cs (3)

84builder.Append(Environment.NewLine); 91builder.Append(Environment.NewLine); 116builder.Append(Environment.NewLine);

System\Data\Common\AdapterUtil.cs (2)

926internal static readonly bool IsWindowsNT = (PlatformID.Win32NT == Environment.OSVersion.Platform); 927internal static readonly bool IsPlatformNT5 = (ADP.IsWindowsNT && (Environment.OSVersion.Version.Major >= 5));

System\Data\ProviderBase\DbConnectionFactory.cs (1)

26private static readonly Task<DbConnectionInternal?>[] s_pendingOpenNonPooled = new Task<DbConnectionInternal?>[Environment.ProcessorCount];

System.Diagnostics.DiagnosticSource (7)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

System\Diagnostics\LocalAppContextSwitches.cs (1)

18string? switchValue = Environment.GetEnvironmentVariable("DOTNET_SYSTEM_DIAGNOSTICS_DEFAULTACTIVITYIDFORMATISHIERARCHIAL");

System\Diagnostics\Metrics\CounterAggregator.cs (1)

21private readonly PaddedDouble[] _deltas = new PaddedDouble[Math.Min(Environment.ProcessorCount, 8)];

System\Diagnostics\Metrics\RuntimeMetrics.cs (4)

40() => Environment.WorkingSet, 145() => (long)Environment.ProcessorCount, 179Environment.ProcessCpuUsage processCpuUsage = Environment.CpuUsage;

System.Diagnostics.EventLog (4)

src\runtime\src\libraries\Common\src\System\Diagnostics\NetFrameworkUtils.cs (2)

146string versionPrefix = "v" + Environment.Version.Major + "." + Environment.Version.Minor;

System\Diagnostics\Reader\EventLogWatcher.cs (2)

109if (_callbackThreadId != Environment.CurrentManagedThreadId) 211_callbackThreadId = Environment.CurrentManagedThreadId;

System.Diagnostics.PerformanceCounter (8)

misc\EnvironmentHelpers.cs (3)

21if (Environment.OSVersion.Version.Major < 6 || (Environment.OSVersion.Version.Major == 6 && Environment.OSVersion.Version.Minor <= 1))

src\runtime\src\libraries\Common\src\System\Diagnostics\NetFrameworkUtils.cs (2)

146string versionPrefix = "v" + Environment.Version.Major + "." + Environment.Version.Minor;

System\Diagnostics\PerformanceCounterLib.cs (3)

1201processStartInfo.WorkingDirectory = Environment.SystemDirectory; 1204processStartInfo.FileName = Environment.SystemDirectory + "\\unlodctr.exe"; 1206processStartInfo.FileName = Environment.SystemDirectory + "\\lodctr.exe";

System.Diagnostics.Process (17)

System\Diagnostics\Process.cs (2)

1131private bool IsCurrentProcess => _processId == Environment.ProcessId; 1141return new Process(".", false, Environment.ProcessId, null);

System\Diagnostics\Process.Linux.cs (4)

18get => IsCurrentProcess ? Environment.CpuUsage.PrivilegedTime : TicksToTimeSpan(GetStat().stime); 88return Environment.CpuUsage.TotalTime; 98get => IsCurrentProcess ? Environment.CpuUsage.UserTime : TicksToTimeSpan(GetStat().utime); 208return procPid == Interop.procfs.ProcPid.Self ? Environment.ProcessPath :

System\Diagnostics\Process.Multiplexing.cs (1)

689long remaining = deadline - Environment.TickCount64;

System\Diagnostics\Process.Multiplexing.Unix.cs (2)

54long deadline = timeoutMs >= 0 ? Environment.TickCount64 + timeoutMs : long.MaxValue; 284? Environment.TickCount64 + timeoutMs

System\Diagnostics\ProcessManager.Linux.cs (3)

191yield return Environment.ProcessId; 265if (pid == Environment.ProcessId) 298_procMatchesPidNamespace = !procSelfPid.HasValue || procSelfPid == Environment.ProcessId ? NullableBool.True : NullableBool.False;

System\Diagnostics\ProcessStartInfo.cs (1)

100IDictionary envVars = System.Environment.GetEnvironmentVariables();

System\Diagnostics\ProcessUtils.Unix.cs (2)

63string? pathEnvVar = Environment.GetEnvironmentVariable("PATH"); 371string? path = Environment.ProcessPath;

System\Diagnostics\ProcessWaitState.Unix.cs (2)

603Environment.FailFast("Error while reaping child. errno = " + errorCode); 649Environment.FailFast("Error while checking for terminated children. errno = " + errorCode);

System.Diagnostics.TextWriterTraceListener (3)

System\Diagnostics\XmlWriterTraceListener.cs (3)

20private readonly string _machineName = Environment.MachineName; 271InternalWrite((uint)Environment.ProcessId); 273InternalWrite((uint)Environment.CurrentManagedThreadId);

System.Diagnostics.TraceSource (9)

System\Diagnostics\DefaultTraceListener.cs (6)

106WriteLine(SR.DebugAssertBanner + Environment.NewLine 107+ SR.DebugAssertShortMessage + Environment.NewLine 108+ message + Environment.NewLine 109+ SR.DebugAssertLongMessage + Environment.NewLine 110+ detailMessage + Environment.NewLine 140Write(message + Environment.NewLine, useLogFile);

System\Diagnostics\TraceEventCache.cs (3)

31return Environment.ProcessId; 39return Environment.CurrentManagedThreadId.ToString(CultureInfo.InvariantCulture); 53public string Callstack => field ??= Environment.StackTrace;

System.DirectoryServices (5)

System\DirectoryServices\ActiveDirectory\DirectoryContext.cs (1)

685string systemPath = Environment.SystemDirectory;

System\DirectoryServices\ActiveDirectory\Exception.cs (2)

167return s + Environment.NewLine + SR.Format(SR.Name, Name) + Environment.NewLine;

System\DirectoryServices\ActiveDirectory\ReplicationCursor.cs (2)

74if ((Environment.OSVersion.Version.Major == 5) && (Environment.OSVersion.Version.Minor == 0))

System.DirectoryServices.AccountManagement (2)

System\DirectoryServices\AccountManagement\Context.cs (1)

75_serverName = Environment.MachineName;

System\DirectoryServices\AccountManagement\Utils.cs (1)

548string s = Environment.MachineName;

System.DirectoryServices.Protocols (1)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

System.Formats.Tar (3)

System\Formats\Tar\TarHeader.Write.cs (3)

1136$"{dirName}/PaxHeaders.{Environment.ProcessId}/{fileName}{Path.DirectorySeparatorChar}" : 1137$"{dirName}/PaxHeaders.{Environment.ProcessId}/{fileName}"; 1153string result = $"{tmp}/GlobalHead.{Environment.ProcessId}.{globalExtendedAttributesEntryNumber}";

System.IO.Compression (1)

System\IO\Compression\Zstandard\ZstandardUtils.cs (1)

18internal static int WindowLog_Max => Environment.Is64BitProcess ? 31 : 30; // 1GB or 2GB window, depending on platform

System.IO.IsolatedStorage (7)

System\IO\IsolatedStorage\Helper.cs (1)

129location = Environment.ProcessPath;

System\IO\IsolatedStorage\Helper.NonMobile.cs (6)

20Environment.SpecialFolder specialFolder = 21IsMachine(scope) ? Environment.SpecialFolder.CommonApplicationData : // e.g. C:\ProgramData 22IsRoaming(scope) ? Environment.SpecialFolder.ApplicationData : // e.g. C:\Users\Joe\AppData\Roaming 23Environment.SpecialFolder.LocalApplicationData; // e.g. C:\Users\Joe\AppData\Local 25string dataDirectory = Environment.GetFolderPath(specialFolder, Environment.SpecialFolderOption.Create);

System.IO.Pipes (3)

System\IO\Pipes\NamedPipeClientStream.cs (3)

130ConnectInternal(timeout, CancellationToken.None, Environment.TickCount); 163while (timeout == Timeout.Infinite || (elapsed = unchecked(Environment.TickCount - startTime)) < timeout); 196int startTime = Environment.TickCount; // We need to measure time here, not in the lambda

System.IO.Ports (8)

System\IO\Ports\SerialPort.cs (6)

771int startTicks = Environment.TickCount; 779timeUsed = Environment.TickCount - startTicks; 826int startTicks = Environment.TickCount; 876} while (timeout == InfiniteTimeout || (timeout - GetElapsedTime(Environment.TickCount, startTicks) > 0)); 1091timeNow = Environment.TickCount; 1093timeUsed += Environment.TickCount - timeNow;

System\IO\Ports\SerialStream.Unix.cs (2)

920ticksWhenIdleStarted = Environment.TickCount; 922else if (Environment.TickCount - ticksWhenIdleStarted > IOLoopIdleTimeout)

System.Linq (2)

System\Linq\Iterator.cs (2)

33private readonly int _threadId = Environment.CurrentManagedThreadId; 74Iterator<TSource> enumerator = _state == 0 && _threadId == Environment.CurrentManagedThreadId ? this : Clone();

System.Linq.AsyncEnumerable (2)

System\Linq\AsyncIterator.cs (2)

34private readonly int _threadId = Environment.CurrentManagedThreadId; 77AsyncIterator<TSource> enumerator = _state == 0 && _threadId == Environment.CurrentManagedThreadId ? this : Clone();

System.Linq.Parallel (3)

System\Linq\Parallel\Channels\AsynchronousChannel.cs (2)

207Environment.CurrentManagedThreadId); 221Environment.CurrentManagedThreadId);

System\Linq\Parallel\Scheduling\Scheduling.cs (1)

34internal static readonly int DefaultDegreeOfParallelism = Math.Min(Environment.ProcessorCount, MAX_SUPPORTED_DOP);

System.Management (8)

System\Management\InteropClasses\WMIInterop.cs (1)

1371OperatingSystem os = Environment.OSVersion;

System\Management\ManagementEventWatcher.cs (1)

626(string.Equals(eventWatcher.Scope.Path.Server, System.Environment.MachineName, StringComparison.OrdinalIgnoreCase)))

System\Management\ManagementScope.cs (4)

986if (Environment.OSVersion.Platform == PlatformID.Win32NT) 989if (((Environment.OSVersion.Version.Major == 5) && (Environment.OSVersion.Version.Minor >= 1)) || (Environment.OSVersion.Version.Major >= 6))

System\Management\WmiEventSink.cs (2)

79(string.Equals(this.path.Server, System.Environment.MachineName, StringComparison.OrdinalIgnoreCase))) 91(string.Equals(this.scope.Path.Server, System.Environment.MachineName, StringComparison.OrdinalIgnoreCase)))

System.Net.Http (36)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

src\runtime\src\libraries\Common\src\System\Net\Http\UriRedactionHelper.cs (1)

20string? envVar = Environment.GetEnvironmentVariable("DOTNET_SYSTEM_NET_HTTP_DISABLEURIREDACTION");

System\Net\Http\Headers\HeaderUtilities.cs (1)

336sb.Append(Environment.NewLine);

System\Net\Http\Headers\HttpHeaders.cs (1)

362builder.Append(Environment.NewLine);

System\Net\Http\HttpRequestMessage.cs (1)

226sb.Append(Environment.NewLine);

System\Net\Http\HttpResponseMessage.cs (2)

195sb.Append(Environment.NewLine); 201sb.Append(Environment.NewLine);

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.cs (1)

1089long nowTicks = Environment.TickCount64;

System\Net\Http\SocketsHttpHandler\FailedProxyCache.cs (7)

34private long _nextFlushTicks = Environment.TickCount64 + FlushFailuresTimerInMilliseconds; 44/// <returns>If the proxy can be used, <see cref="Immediate"/>. Otherwise, the next <see cref="Environment.TickCount64"/> that it should be used.</returns> 56if (Environment.TickCount64 < renewTicks) 78_failedProxies[uri] = Environment.TickCount64 + FailureTimeoutInMilliseconds; 96if (_failedProxies.Count > LargeProxyConfigBoundary && Environment.TickCount64 >= Interlocked.Read(ref _nextFlushTicks)) 122long curTicks = Environment.TickCount64; 136Interlocked.Exchange(ref _nextFlushTicks, Environment.TickCount64 + FlushFailuresTimerInMilliseconds);

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (3)

165_nextPingRequestTimestamp = Environment.TickCount64 + _keepAlivePingDelay; 2210_nextPingRequestTimestamp = Environment.TickCount64 + _keepAlivePingDelay; 2244long now = Environment.TickCount64;

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (1)

293GetIdleTicks(Environment.TickCount64) >= _keepAliveTimeoutSeconds * 1000;

System\Net\Http\SocketsHttpHandler\HttpConnectionBase.cs (4)

30private readonly long _creationTickCount = Environment.TickCount64; 163if (GlobalHttpSettings.MetricsHandler.IsGloballyEnabled) _connectionMetrics?.ConnectionClosed(durationMs: Environment.TickCount64 - _creationTickCount); 179_idleSinceTickCount = Environment.TickCount64; 234internal TimeSpan Age => TimeSpan.FromMilliseconds(GetLifetimeTicks(Environment.TickCount64));

System\Net\Http\SocketsHttpHandler\HttpEnvironmentProxy.Unix.cs (9)

System\Net\Http\SocketsHttpHandler\RuntimeSettingParser.cs (3)

25string? envVar = Environment.GetEnvironmentVariable(environmentVariableSettingName); 80string? envVar = Environment.GetEnvironmentVariable(environmentVariableSettingName); 94string? envVar = Environment.GetEnvironmentVariable(environmentVariableSettingName);

System\Net\Http\SocketsHttpHandler\SocketsHttpConnectionEvictionContext.cs (1)

80public TimeSpan Age => TimeSpan.FromMilliseconds(Environment.TickCount64 - _creationTickCount);

System.Net.Http.WinHttpHandler (4)

src\runtime\src\libraries\Common\src\System\Runtime\ExceptionServices\ExceptionStackTrace.cs (3)

24Environment.StackTrace + Environment.NewLine + 25"--- End of stack trace from AddCurrentStack ---" + Environment.NewLine;

System\Net\Http\WinHttpRequestCallback.cs (1)

39if (Environment.HasShutdownStarted)

System.Net.HttpListener (1)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

System.Net.NameResolution (1)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

System.Net.NetworkInformation (21)

src\runtime\src\libraries\Common\src\System\IO\RowConfigReader.cs (5)

88int endOfLine = _buffer.IndexOf(Environment.NewLine, afterKey, _comparisonKind); 135|| (keyIndex >= Environment.NewLine.Length && _buffer.AsSpan(keyIndex - Environment.NewLine.Length, Environment.NewLine.Length).SequenceEqual(Environment.NewLine)))

System\Net\NetworkInformation\StringParsingHelpers.Addresses.cs (3)

140int labelLineStart = fileContents.LastIndexOf(Environment.NewLine, labelIndex, StringComparison.Ordinal); 157labelLineStart = fileContents.LastIndexOf(Environment.NewLine, labelIndex, StringComparison.Ordinal); 159int endOfLine = fileContents.IndexOf(Environment.NewLine, labelIndex, StringComparison.Ordinal);

System\Net\NetworkInformation\StringParsingHelpers.Connections.cs (7)

17int endOfTcpLine = sockstatFile.IndexOf(Environment.NewLine, indexOfTcp + 1, StringComparison.Ordinal); 33v4connections = tcp4FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 43v6connections = tcp6FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 113v4connections = tcp4FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 123v6connections = tcp6FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 193v4connections = udp4FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries); 203v6connections = udp6FileContents.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);

System\Net\NetworkInformation\StringParsingHelpers.Misc.cs (2)

66return routeFile.AsSpan().Count(Environment.NewLine) - 1; // File includes one-line header 92int endOfSecondLine = snmp4FileContents.IndexOf(Environment.NewLine, secondIpHeader, StringComparison.Ordinal);

System\Net\NetworkInformation\StringParsingHelpers.Statistics.cs (4)

182int endOfSecondLine = fileContents.IndexOf(Environment.NewLine, secondIpHeader, StringComparison.Ordinal); 269int endOfSecondLine = fileContents.IndexOf(Environment.NewLine, secondIpHeader, StringComparison.Ordinal); 336int endOfSecondLine = fileContents.IndexOf(Environment.NewLine, secondTcpHeader, StringComparison.Ordinal); 368int endOfSecondLine = fileContents.IndexOf(Environment.NewLine, secondUdpHeader, StringComparison.Ordinal);

System.Net.Ping (3)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

src\runtime\src\libraries\Common\src\System\Net\NetworkInformation\UnixCommandLinePing.cs (2)

104if (ipv4 || Environment.OSVersion.Version.Major > 12) 150if (ipv4 || (OperatingSystem.IsFreeBSD() && Environment.OSVersion.Version.Major > 12))

System.Net.Quic (3)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

src\runtime\src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (1)

11private static readonly string? s_keyLogFile = Environment.GetEnvironmentVariable("SSLKEYLOGFILE");

System\Net\Quic\Internal\MsQuicApi.cs (1)

204NotSupportedReason = $"Current Windows version ({Environment.OSVersion}) is not supported by QUIC. Minimal supported version is {s_minWindowsVersion}.";

System.Net.Requests (4)

System\Net\TimerThread.cs (4)

51_startTimeMilliseconds = Environment.TickCount; 387int nowMilliseconds = Environment.TickCount; 517int now = Environment.TickCount; 546int newNow = Environment.TickCount;

System.Net.Security (4)

src\runtime\src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (1)

133string? value = AppContext.GetData(TlsCacheSizeCtxName) as string ?? Environment.GetEnvironmentVariable(TlsCacheSizeEnvironmentVariable);

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

src\runtime\src\libraries\Common\src\System\Net\Security\SslKeyLogger.cs (1)

11private static readonly string? s_keyLogFile = Environment.GetEnvironmentVariable("SSLKEYLOGFILE");

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (1)

57private static readonly byte[] s_workstation = Encoding.Unicode.GetBytes(Environment.MachineName);

System.Net.Sockets (11)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

System\Net\Sockets\SocketAsyncContext.Unix.cs (2)

903Environment.FailFast("unexpected queue state"); 991Environment.FailFast("unexpected queue state");

System\Net\Sockets\SocketAsyncEngine.Unix.cs (5)

26internal static readonly bool InlineSocketCompletionsEnabled = Environment.GetEnvironmentVariable("DOTNET_SYSTEM_NET_SOCKETS_INLINE_COMPLETIONS") == "1"; 63if (uint.TryParse(Environment.GetEnvironmentVariable("DOTNET_SYSTEM_NET_SOCKETS_THREAD_COUNT"), out uint count)) 71return Environment.ProcessorCount; 79return Math.Max(1, (int)Math.Round(Environment.ProcessorCount / (double)coresPerEngine)); 247Environment.FailFast("Exception thrown from SocketAsyncEngine event loop: " + e.ToString(), e);

System\Net\Sockets\SocketAsyncEventArgs.cs (1)

525if (!Environment.HasShutdownStarted)

System\Net\Sockets\SocketPal.Unix.cs (2)

970long start = socket.IsUnderlyingHandleBlocking && socket.SendTimeout > 0 ? Environment.TickCount64 : 0; // Get ticks only if timeout is set and socket is blocking. 1023if (socket.IsUnderlyingHandleBlocking && socket.SendTimeout > 0 && (Environment.TickCount64 - start) >= socket.SendTimeout)

System.Net.WebSockets (4)

System\Net\WebSockets\ManagedWebSocket.KeepAlive.cs (4)

70long now = Environment.TickCount64; 147NextPingRequestTimestamp = Environment.TickCount64 + DelayMs; 158NextPingRequestTimestamp = Environment.TickCount64 + DelayMs; 193PingTimeoutTimestamp = Environment.TickCount64 + TimeoutMs;

System.Private.CoreLib (216)

Internal\IntrinsicSupport\ComparerHelpers.cs (1)

88Environment.FailFast("Unable to create comparer");

Internal\IntrinsicSupport\EqualityComparerHelpers.cs (1)

101Environment.FailFast("Unable to create comparer");

Internal\Runtime\CompilerHelpers\StartupCode\StartupCodeHelpers.Extensions.cs (6)

30Environment.s_commandLineArgs = args; 40Environment.s_commandLineArgs = args; 46string[]? args = Environment.s_commandLineArgs; 60Environment.ExitCode = exitCode; 68Environment.ShutdownCore(); 70int exitCode = Environment.ExitCode;

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

src\runtime\src\libraries\System.Private.CoreLib\src\Internal\Console.cs (3)

18Write(s + Environment.NewLineConst); 22Write(Environment.NewLineConst); 28Write(Environment.NewLineConst);

src\runtime\src\libraries\System.Private.CoreLib\src\System\AggregateException.cs (1)

376text.Append(Environment.NewLineConst + InnerExceptionPrefix);

src\runtime\src\libraries\System.Private.CoreLib\src\System\AppContext.AnyOS.cs (1)

22string? path = Environment.ProcessPath;

src\runtime\src\libraries\System.Private.CoreLib\src\System\AppContextConfigHelper.cs (9)

src\runtime\src\libraries\System.Private.CoreLib\src\System\AppDomain.cs (2)

181SR.AppDomain_Name + FriendlyName + Environment.NewLineConst + SR.AppDomain_NoContextPolicies; 229public static int GetCurrentThreadId() => Environment.CurrentManagedThreadId;

src\runtime\src\libraries\System.Private.CoreLib\src\System\ArgumentOutOfRangeException.cs (1)

81return s + Environment.NewLineConst + valueMessage;

src\runtime\src\libraries\System.Private.CoreLib\src\System\BadImageFormatException.cs (5)

101s += Environment.NewLineConst + SR.Format(SR.IO_FileName_Name, _fileName); 104s += Environment.NewLineConst + SR.Format(SR.IO_FileLoad_RequestedBy, _requestingAssemblyChain); 110s += Environment.NewLineConst + StackTrace; 115s += Environment.NewLineConst + Environment.NewLineConst + _fusionLog;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\SharedArrayPool.cs (4)

193int currentMilliseconds = Environment.TickCount; 510/// <remarks>Defaults to int.MaxValue. Whatever value is returned will end up being clamped to <see cref="Environment.ProcessorCount"/>.</remarks> 516return Math.Min(partitionCount, Environment.ProcessorCount); 534if (Environment.GetEnvironmentVariableCore_NoArrayPool(variable) is string envVar &&

src\runtime\src\libraries\System.Private.CoreLib\src\System\Collections\Concurrent\ConcurrentDictionary.cs (1)

2054private static int DefaultConcurrencyLevel => Environment.ProcessorCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\DebugProvider.cs (8)

36WriteLine(SR.DebugAssertBanner + Environment.NewLineConst 37+ SR.DebugAssertShortMessage + Environment.NewLineConst 38+ message + Environment.NewLineConst 39+ SR.DebugAssertLongMessage + Environment.NewLineConst 40+ detailMessage + Environment.NewLineConst 59if (message.EndsWith(Environment.NewLineConst, StringComparison.Ordinal)) 68Write(message + Environment.NewLineConst); 91s += Environment.NewLineConst;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\DebugProvider.Unix.cs (2)

8private static readonly bool s_shouldWriteToStdErr = Environment.GetEnvironmentVariable("DOTNET_DebugWriteToStdErr") == "1"; 28Environment.FailFast(ex.Message, ex, errorSource);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\ActivityTracker.cs (1)

492sumPtr[3] = (sumPtr[0] + sumPtr[1] + sumPtr[2] + 0x599D99AD) ^ (uint)Environment.ProcessId;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (2)

3341msg += Environment.NewLine; 3838Debugger.Log(0, null, $"EventSource Error: {msg}{Environment.NewLine}");

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\RuntimeEventSource.cs (2)

80_workingSetCounter ??= new PollingCounter("working-set", this, () => ((double)Environment.WorkingSet / 1_000_000)) { DisplayName = "Working Set", DisplayUnits = "MB" }; 113ProcessorCount(Environment.ProcessorCount);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\RuntimeEventSourceHelper.Unix.cs (1)

11Interop.Sys.GetCpuUtilization(ref s_cpuInfo) / Environment.ProcessorCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Exception.cs (8)

142length += Environment.NewLineConst.Length + InnerExceptionPrefix.Length + innerExceptionString.Length + Environment.NewLineConst.Length + 3 + endOfInnerExceptionResource.Length; 146length += Environment.NewLineConst.Length + stackTrace.Length; 163Write(Environment.NewLineConst, ref resultSpan); 166Write(Environment.NewLineConst, ref resultSpan); 172Write(Environment.NewLineConst, ref resultSpan); 261_remoteStackTraceString = stackTrace + Environment.NewLineConst + SR.Exception_EndStackTraceFromPreviousThrow + Environment.NewLineConst;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\CultureNotFoundException.cs (1)

103return s + Environment.NewLineConst + valueMessage;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\GlobalizationMode.cs (2)

53value = Environment.GetEnvironmentVariable(envVariable); 93Environment.FailFast($"Failed to load app-local ICU: {library}");

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\GlobalizationMode.Unix.cs (1)

31Environment.FailFast(GetIcuLoadFailureMessage());

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\Directory.cs (2)

260public static string GetCurrentDirectory() => Environment.CurrentDirectory; 266Environment.CurrentDirectory = Path.GetFullPath(path);

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\DirectoryNotFoundException.cs (3)

59s += Environment.NewLineConst + SR.Format(SR.IO_DirectoryName_Name, DirectoryPath); 62s += Environment.NewLineConst + InnerExceptionPrefix + InnerException.ToString(); 65s += Environment.NewLineConst + StackTrace;

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\FileLoadException.cs (6)

56s += Environment.NewLineConst + SR.Format(SR.IO_FileName_Name, FileName); 59s += Environment.NewLineConst + SR.Format(SR.IO_FileLoad_RequestedBy, _requestingAssemblyChain); 62s += Environment.NewLineConst + InnerExceptionPrefix + InnerException.ToString(); 65s += Environment.NewLineConst + StackTrace; 70s += Environment.NewLineConst + Environment.NewLineConst + FusionLog;

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\FileNotFoundException.cs (6)

79s += Environment.NewLineConst + SR.Format(SR.IO_FileName_Name, FileName); 82s += Environment.NewLineConst + SR.Format(SR.IO_FileLoad_RequestedBy, _requestingAssemblyChain); 85s += Environment.NewLineConst + InnerExceptionPrefix + InnerException.ToString(); 88s += Environment.NewLineConst + StackTrace; 93s += Environment.NewLineConst + Environment.NewLineConst + FusionLog;

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\Iterator.cs (2)

21_threadId = Environment.CurrentManagedThreadId; 42if (state == 0 && _threadId == Environment.CurrentManagedThreadId)

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\Path.Unix.cs (1)

88string? path = Environment.GetEnvironmentVariable(TempEnvVar);

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\PersistedFiles.Unix.cs (1)

54string? userHomeDirectory = Environment.GetEnvironmentVariable("HOME");

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\SharedMemoryManager.Unix.cs (3)

24private static int SessionId { get; } = Interop.Sys.GetSid(Environment.ProcessId); 167nuint sharedDataTotalByteCount = AlignUp(sharedDataUsedByteCount, (nuint)Environment.SystemPageSize); 397string? applicationGroupId = Environment.GetEnvironmentVariable("DOTNET_SHARED_MEMORY_APPLICATION_GROUP_ID");

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.cs (6)

27private static readonly char[] s_coreNewLine = Environment.NewLineConst.ToCharArray(); 40private string CoreNewLineStr = Environment.NewLineConst; 117value ??= Environment.NewLineConst; 123value == Environment.NewLineConst ? s_coreNewLine : // current OS default 124Environment.NewLineConst == "\r\n" && value == "\n" ? (s_otherCoreNewLine ??= ['\n']) : // other OS default 125Environment.NewLineConst == "\n" && value == "\r\n" ? (s_otherCoreNewLine ??= ['\r', '\n']) : // other OS default

src\runtime\src\libraries\System.Private.CoreLib\src\System\ObjectDisposedException.cs (1)

100return base.Message + Environment.NewLineConst + objectDisposed;

src\runtime\src\libraries\System.Private.CoreLib\src\System\OperatingSystem.cs (1)

360Version current = Environment.OSVersion.Version;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\FileBasedResourceGroveler.cs (1)

44throw new MissingManifestResourceException($"{SR.MissingManifestResource_NoNeutralDisk}{Environment.NewLineConst}baseName: {_mediator.BaseNameField} fileName: {_mediator.GetResourceFileName(culture)}");

src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\ManifestBasedResourceGroveler.cs (3)

467Debug.Fail("Couldn't get " + CoreLib.Name + ResourceManager.ResFileExtension + " from " + CoreLib.Name + "'s assembly" + Environment.NewLineConst + Environment.NewLineConst + "Are you building the runtime on your machine? Chances are the BCL directory didn't build correctly. Type 'build -c' in the BCL directory. If you get build errors, look at buildd.log. If you then can't figure out what's wrong (and you aren't changing the assembly-related metadata code), ask a BCL dev.\n\nIf you did NOT build the runtime, you shouldn't be seeing this and you've found a bug."); 471System.Environment.FailFast(MesgFailFast);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\AsyncProfiler.cs (1)

196string? eventBufferSizeEnv = System.Environment.GetEnvironmentVariable("DOTNET_AsyncProfiler_EventBufferSize");

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\PoolingAsyncValueTaskMethodBuilderT.cs (4)

318private static readonly PaddedReference[] s_perCoreCache = new PaddedReference[Environment.ProcessorCount]; 387Debug.Assert(s_perCoreCache.Length == Environment.ProcessorCount, $"{s_perCoreCache.Length} != {Environment.ProcessorCount}"); 388int i = (int)((uint)Thread.GetCurrentProcessorId() % (uint)Environment.ProcessorCount);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\SwitchExpressionException.cs (1)

63return base.Message + Environment.NewLine + valueMessage;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\COMException.cs (1)

65s.Append(Environment.NewLineConst + InnerExceptionPrefix).Append(innerException.ToString());

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ComWrappers.cs (1)

1380uint bucketCount = BitOperations.RoundUpToPowerOf2((uint)Math.Min(Environment.ProcessorCount, MaxBucketCount));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ExternalException.cs (2)

64s += Environment.NewLineConst + InnerExceptionPrefix + innerException.ToString(); 68s += Environment.NewLineConst + StackTrace;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NativeLibrary.Unix.cs (2)

51_errorMessage ??= Environment.NewLine; 54_errorMessage += message + Environment.NewLine;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\MemoryFailPoint.cs (1)

194long now = Environment.TickCount; // Handle wraparound.

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Versioning\VersioningHelper.cs (1)

53safeName.Append(Environment.ProcessId);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Security\SecurityElement.cs (4)

431write(obj, Environment.NewLineConst); 440write(obj, Environment.NewLineConst); 453write(obj, Environment.NewLineConst); 465write(obj, Environment.NewLineConst);

src\runtime\src\libraries\System.Private.CoreLib\src\System\SR.cs (1)

71Environment.FailFast(message);

src\runtime\src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (4)

1493/// Replaces all newline sequences in the current string with <see cref="Environment.NewLine"/>. 1497/// with <see cref="Environment.NewLine"/>. 1513/// <see cref="Environment.NewLine"/> as the replacementText parameter. 1517public string ReplaceLineEndings() => ReplaceLineEndings(Environment.NewLineConst);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (2)

887public StringBuilder AppendLine() => Append(Environment.NewLine); 892return Append(Environment.NewLine);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\CancellationTokenRegistration.cs (2)

52node.Registrations.ThreadIDExecutingCallbacks != Environment.CurrentManagedThreadId) // The executing thread ID is not this thread's ID. 82node.Registrations.ThreadIDExecutingCallbacks != Environment.CurrentManagedThreadId) // The executing thread ID is not this thread's ID.

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\CancellationTokenSource.cs (3)

743registrations.ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId; 798n.Registrations.ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId; 801registrations.ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId; // above may have altered ThreadIDExecutingCallbacks, so reset it

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\ExecutionContext.cs (1)

452Environment.FailFast(

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\Lock.cs (5)

575int waitStartTimeMs = timeoutMs < 0 ? 0 : Environment.TickCount; 620uint waitDurationMs = (uint)(Environment.TickCount - waitStartTimeMs); 664ushort currentTimeMs = (ushort)Environment.TickCount; 682(ushort)(Environment.TickCount - waiterStartTimeMs) >= MaxDurationMsForPreemptingWaiters; 878s_isSingleProcessor = Environment.GetProcessorCount() == 1;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\LowLevelLifoSemaphore.cs (1)

111int spinsRemaining = Environment.IsSingleProcessor ? 0 : _maxSpinCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\LowLevelLock.cs (1)

130uint spinCount = Environment.IsSingleProcessor ? 0 : SpinCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\LowLevelSpinWaiter.cs (1)

23int processorCount = Environment.ProcessorCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\LowLevelThreadBlocker.cs (2)

152long deadline = Environment.TickCount64 + timeoutMs; 163timeoutMs = (int)(deadline - Environment.TickCount64);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\ManualResetEventSlim.cs (2)

224SpinCount = Environment.IsSingleProcessor ? DEFAULT_SPIN_SP : spinCount; 539startTime = Environment.TickCount64;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\NamedMutex.Unix.cs (6)

302return ownerProcessId == (uint)Environment.ProcessId && 310(uint)Environment.ProcessId, 428return _sharedData->LockOwnerProcessId == (uint)Environment.ProcessId && 434_sharedData->LockOwnerProcessId = (uint)Environment.ProcessId; 481startTime = Environment.TickCount; 552int elapsedMilliseconds = Environment.TickCount - startTime;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.Blocking.cs (1)

320int processorCount = Environment.ProcessorCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.cs (2)

144_minThreads = HasForcedMinThreads ? ForcedMinWorkerThreads : (short)Environment.ProcessorCount; 409int currentTicks = Environment.TickCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.GateThread.cs (5)

47lastCpuUtilizationRefreshTimeMs = Environment.TickCount; 65int currentTimeMs = Environment.TickCount; 71currentTimeMs = Environment.TickCount; 211uint delay = (uint)(Environment.TickCount - threadPoolInstance._separated.lastDispatchTime); 273Environment.FailFast("Failed to create the thread pool Gate thread.", e);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.HillClimbing.cs (1)

416entry.tickCount = Environment.TickCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.Unix.cs (1)

18Interop.Sys.GetCpuUtilization(ref _cpuInfo) / Environment.ProcessorCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.WaitThread.cs (2)

207int currentTimeMs = Environment.TickCount; 272currentTimeMs = Environment.TickCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.WorkerThread.cs (2)

45short DefaultSpuriousDispatchNoSpinThreshold = (short)(Environment.ProcessorCount * 2 / 3); 156threadPoolInstance.NotifyDispatchProgress(Environment.TickCount);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\ProcessorIdCache.cs (1)

38currentProcessorId = Environment.CurrentManagedThreadId;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\ReaderWriterLockSlim.cs (13)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\RegisteredWaitHandle.Portable.cs (1)

90TimeoutTimeMs = Environment.TickCount + TimeoutDurationMs;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\SemaphoreSlim.cs (1)

328startTime = Environment.TickCount64;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\SpinLock.cs (4)

293startTime = Environment.TickCount64; 351if (turn > Environment.ProcessorCount) 414int newOwner = Environment.CurrentManagedThreadId; 576return (_owner & (~LOCK_ID_DISABLE_MASK)) == Environment.CurrentManagedThreadId;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\SpinWait.cs (5)

88internal static readonly int SpinCountForSpinBeforeWait = Environment.IsSingleProcessor ? 1 : 35; 116public bool NextSpinWillYield => _count >= YieldThreshold || Environment.IsSingleProcessor; 174Environment.IsSingleProcessor) 314startTime = (uint)Environment.TickCount; 328if (millisecondsTimeout <= (uint)Environment.TickCount - startTime)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\ConcurrentExclusiveSchedulerPair.cs (1)

64private static int DefaultMaxConcurrencyLevel => Environment.ProcessorCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (2)

3213uint startTimeTicks = infiniteWait ? 0 : (uint)Environment.TickCount; 3257uint elapsedTimeTicks = ((uint)Environment.TickCount) - startTimeTicks;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\TplEventSource.cs (1)

574int pid = Environment.ProcessId;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\ThreadPoolWorkQueue.cs (4)

420Environment.ProcessorCount <= 32 ? 0 : 421(Environment.ProcessorCount + (ProcessorsPerAssignableWorkItemQueue - 1)) / ProcessorsPerAssignableWorkItemQueue; 949int startTickCount = Environment.TickCount; 1024int currentTickCount = Environment.TickCount;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\TimeoutHelper.cs (1)

24ulong elapsedMilliseconds = (ulong)(Environment.TickCount64 - startTime);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\Timer.cs (7)

45internal static readonly (long TickCount, DateTime Time) s_tickCountToTimeMap = (Environment.TickCount64, DateTime.UtcNow); 51var queues = new TimerQueue[Environment.ProcessorCount]; 129long elapsed = Environment.TickCount64 - _currentTimerStartTicks; 141_currentTimerStartTicks = Environment.TickCount64; 164private long _currentAbsoluteThreshold = Environment.TickCount64 + ShortTimersThresholdMilliseconds; 194long nowTicks = Environment.TickCount64; 345long nowTicks = Environment.TickCount64;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\TimerQueue.Portable.cs (2)

53long dueTimeMs = Environment.TickCount64 + (int)actualDuration; 95long currentTimeMs = Environment.TickCount64;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\WaitSubsystem.ThreadWaitInfo.Unix.cs (2)

331int startTimeMilliseconds = Environment.TickCount; 347elapsedMilliseconds = Environment.TickCount - startTimeMilliseconds;

src\runtime\src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.NonAndroid.cs (2)

226string? result = Environment.GetEnvironmentVariable(TimeZoneEnvironmentVariable); 507string? tzDirectory = Environment.GetEnvironmentVariable(TimeZoneDirectoryEnvironmentVariable);

System\Diagnostics\StackTrace.NativeAot.cs (2)

91if (traceFormat == TraceFormat.Normal && builder.Length >= Environment.NewLine.Length) 92builder.Length -= Environment.NewLine.Length;

System\Exception.NativeAot.cs (1)

104Environment.FailFast("Exceptions must derive from the System.Exception class");

System\Runtime\InteropServices\PInvokeMarshal.cs (2)

222Environment.FailFast(SR.Delegate_GarbageCollected); 297Environment.FailFast(SR.Delegate_GarbageCollected);

System\StartupHookProvider.NativeAot.cs (1)

16ProcessStartupHooks(Environment.GetEnvironmentVariable("DOTNET_STARTUP_HOOKS"));

System.Private.DataContractSerialization (1)

System\Runtime\Serialization\DataContractSet.cs (1)

601errorMessage.AppendFormat("{0}\"{1}\" ", Environment.NewLine, conflictingType.AssemblyQualifiedName);

System.Private.TypeLoader (21)

Internal\Runtime\TypeLoader\GenericDictionaryCell.cs (13)

Internal\Runtime\TypeLoader\ModuleList.cs (2)

189Environment.FailFast("Invalid module requested in enumeration: " + preferredModuleHandle.LowLevelToString()); 230Environment.FailFast("Current module queried in wrong enumerator state");

Internal\Runtime\TypeLoader\TypeBuilder.cs (1)

1337Environment.FailFast("MissingTemplateException thrown during lazy generic lookup", e);

Internal\Runtime\TypeLoader\TypeLoaderEnvironment.ConstructedGenericsRegistration.cs (1)

120Environment.FailFast("Exception during registration rollback", e);

Internal\Runtime\TypeLoader\TypeLoaderEnvironment.cs (2)

134Environment.FailFast("TypeLoaderLock not held"); 146Environment.FailFast("Reentrant lazy generic lookup");

Internal\Runtime\TypeLoader\TypeLoaderEnvironment.GVMResolution.cs (2)

117Environment.FailFast(sb.ToString()); 157Environment.FailFast(sb.ToString());

System.Private.Windows.Core (17)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\Windows.Win32.IAdviseSink.g.cs (5)

83 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 113 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 143 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 169 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 194 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex);

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\Windows.Win32.IRecordInfo.g.cs (2)

598 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 630 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex);

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\Windows.Win32.ITypeInfo.g.cs (3)

866 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 904 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 942 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex);

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\Windows.Win32.ITypeLib.g.cs (2)

69 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 489 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex);

Windows\Win32\Graphics\GdiPlus\GdiplusStartupInputEx.cs (1)

10OperatingSystem os = Environment.OSVersion;

Windows\Win32\PInvokeCore.GetClassLong.cs (1)

18=> Environment.Is64BitProcess

Windows\Win32\PInvokeCore.GetWindowLong.cs (1)

28nint result = Environment.Is64BitProcess

Windows\Win32\PInvokeCore.SetClassLong.cs (1)

16=> Environment.Is64BitProcess

Windows\Win32\PInvokeCore.SetWindowLong.cs (1)

17nint result = Environment.Is64BitProcess

System.Private.Windows.Core.TestUtilities (7)

NoAssertContext.cs (6)

43s_suppressedThreads.AddOrUpdate(Environment.CurrentManagedThreadId, 1, (key, oldValue) => oldValue + 1); 74int currentThread = Environment.CurrentManagedThreadId; 138if (!s_suppressedThreads.TryGetValue(Environment.CurrentManagedThreadId, out _)) 146if (!s_suppressedThreads.TryGetValue(Environment.CurrentManagedThreadId, out _)) 156if (!s_suppressedThreads.TryGetValue(Environment.CurrentManagedThreadId, out _)) 164if (!s_suppressedThreads.TryGetValue(Environment.CurrentManagedThreadId, out _))

ThrowingTraceListener.cs (1)

15: $"{Environment.NewLine}{detailMessage}")}");

System.Private.Xml (9)

src\runtime\src\libraries\Common\src\System\LocalAppContextSwitches.Common.cs (1)

60if (Environment.GetEnvironmentVariable(envVariable) is string str)

System\Xml\Core\XmlWriterSettings.cs (1)

506_newLineChars = Environment.NewLine; // "\r\n" on Windows, "\n" on Unix

System\Xml\Serialization\SchemaObjectWriter.cs (1)

194_w.Append(Environment.NewLine);

System\Xml\Serialization\XmlSchemas.cs (2)

591err += $"{Environment.NewLine}{Dump(src)}{Environment.NewLine}{Dump(dest)}";

System\Xml\Xsl\QIL\QilValidationVisitor.cs (1)

182message = $"{s}{Environment.NewLine}{message}";

System\Xml\Xsl\XPath\XPathCompileException.cs (1)

118message += Environment.NewLine;

System\Xml\Xsl\XslException.cs (2)

91result += $" ---> {InnerException}{Environment.NewLine} {CreateMessage(SR.Xml_EndOfInnerExceptionStack)}"; 95result += Environment.NewLine + StackTrace;

System.Reflection.Metadata (1)

System\Reflection\Internal\Utilities\ObjectPool`1.cs (1)

42: this(factory, Environment.ProcessorCount * 2)

System.Runtime (1)

src\runtime\artifacts\obj\System.Runtime\Release\net11.0\System.Runtime.Forwards.cs (1)

180[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Environment))]

System.Runtime.Caching (1)

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

359_storeCount = Environment.ProcessorCount;

System.Runtime.Extensions (1)

System.Runtime.Extensions.cs (1)

17[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Environment))]

System.Runtime.InteropServices (1)

System\Runtime\InteropServices\RuntimeEnvironment.cs (1)

37public static string GetSystemVersion() => $"v{Environment.Version}";

System.Runtime.InteropServices.JavaScript (20)

System\Runtime\InteropServices\JavaScript\Interop\JavaScriptExports.CoreCLR.cs (4)

34Environment.FailFast($"ReleaseJSOwnedObjectByGCHandle: Unexpected synchronous failure (ManagedThreadId {Environment.CurrentManagedThreadId}): " + ex); 93Environment.FailFast($"CompleteTask: Unexpected synchronous failure (ManagedThreadId {Environment.CurrentManagedThreadId}): " + ex);

System\Runtime\InteropServices\JavaScript\JSException.cs (1)

80? bs + Environment.NewLine + jsStackTrace

System\Runtime\InteropServices\JavaScript\JSHostImplementation.CoreCLR.cs (2)

54Environment.FailFast($"Can't find {nameSpace}{shortClassName} in {assemblyName} assembly"); 59Environment.FailFast($"Can't find method wrapper {wrapperName} in {nameSpace}.{shortClassName} in {assemblyName} assembly");

System\Runtime\InteropServices\JavaScript\JSProxyContext.cs (4)

495Environment.FailFast($"ReleaseCSOwnedObject expected to find registration for JSHandle: {jsHandle}, ManagedThreadId: {Environment.CurrentManagedThreadId}. {Environment.NewLine} {Environment.StackTrace}");

System\Runtime\InteropServices\JavaScript\Marshaling\JSMarshalerArgument.Task.cs (9)

62Environment.FailFast("Failed to set exception to TaskCompletionSource (arguments buffer is null)"); 73Environment.FailFast("Failed to set exception to TaskCompletionSource (exception raised)"); 80Environment.FailFast("Failed to set result to TaskCompletionSource (marshaler type is none)"); 122Environment.FailFast("Failed to set exception to TaskCompletionSource (arguments buffer is null)"); 135Environment.FailFast("Failed to set exception to TaskCompletionSource (exception raised)"); 143Environment.FailFast("Failed to set result to TaskCompletionSource (marshaler type is none)"); 169Environment.FailFast("Marshalling null return Task to JS is not supported in MT"); 265Environment.FailFast("Marshalling null return Task to JS is not supported in MT"); 341Environment.FailFast("Marshalling null return Task to JS is not supported in MT");

System.Runtime.Numerics (5)

System\Numerics\BigInteger.cs (5)

2882public static explicit operator nint(BigInteger value) => Environment.Is64BitProcess ? (nint)(long)value : (int)value; 3001public static explicit operator nuint(BigInteger value) => Environment.Is64BitProcess ? (nuint)(ulong)value : (uint)value; 4039if (Environment.Is64BitProcess && (uint)(value._bits[^1] >> BitsPerUInt32) == 0) 4095if (!Environment.Is64BitProcess) 4304Debug.Assert(!Environment.Is64BitProcess);

System.Security.Cryptography (1)

src\runtime\src\libraries\Common\src\System\Security\Cryptography\DSACng.cs (1)

66Version version = Environment.OSVersion.Version;

System.Security.Cryptography.Xml (1)

System\Security\Cryptography\Xml\Reference.cs (1)

364string baseUri = (document == null ? System.Environment.CurrentDirectory + "\\" : document.BaseURI);

System.Security.Permissions (3)

System\Security\HostProtectionException.cs (3)

71sb.Append(Environment.NewLine); 72sb.Append(Environment.NewLine); 74sb.Append(Environment.NewLine);

System.Security.Principal.Windows (3)

System\Security\Principal\WindowsIdentity.cs (3)

780Environment.FailFast(Marshal.GetLastPInvokeErrorMessage()); 800Environment.FailFast(Marshal.GetLastPInvokeErrorMessage()); 805Environment.FailFast(Marshal.GetLastPInvokeErrorMessage());

System.ServiceModel.Primitives (11)

Internals\System\Runtime\Fx.cs (1)

172Environment.FailFast(failFastMessage);

Internals\System\Runtime\IOThreadScheduler.cs (1)

240if (!Environment.HasShutdownStarted)

Internals\System\Runtime\SynchronizedPool.cs (3)

212int thisThreadID = Environment.CurrentManagedThreadId; 265int thisThreadID = Environment.CurrentManagedThreadId; 340return Environment.ProcessorCount;

Internals\System\Runtime\TimeoutHelper.cs (1)

295uint currentTime = (uint)Environment.TickCount;

Internals\WcfEventSource.cs (1)

27if (Environment.Version.Major >= 5)

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

449Environment.NewLine,

System\ServiceModel\Security\TimeBoundedCache.cs (3)

295Environment.FailFast("Cache write lock is not held."); 357Environment.FailFast("Cache write lock is not held."); 374Environment.FailFast("Cache write lock is not held.");

System.ServiceModel.Primitives.Tests (2)

ServiceModel\MessageContractTest.4.4.0.cs (2)

175string headerValue = header.ToString().Replace(Environment.NewLine, String.Empty).Replace(" ", String.Empty); 321name, Environment.NewLine, value, errorBuilder.ToString()));

System.Speech (1)

Recognition\RecognizerBase.cs (1)

880OperatingSystem OS = Environment.OSVersion;

System.Text.Json (6)

System\Text\Json\Serialization\JsonSerializerOptions.cs (2)

777/// The default is the value of <see cref="Environment.NewLine"/>. 792return _newLine ??= Environment.NewLine;

System\Text\Json\Writer\JsonWriterOptions.cs (4)

16private static readonly string s_alternateNewLine = Environment.NewLine.Length == 2 ? JsonConstants.NewLineLineFeed : JsonConstants.NewLineCarriageReturnLineFeed; 142/// The default is the value of <see cref="Environment.NewLine"/>. 152get => (_optionsMask & NewLineBit) != 0 ? s_alternateNewLine : Environment.NewLine; 156if (value != Environment.NewLine)

System.Text.RegularExpressions (6)

System\Text\RegularExpressions\RegexLWCGCompiler.cs (1)

26private static readonly bool s_includePatternInName = Environment.GetEnvironmentVariable(IncludePatternInNamesEnvVar) == "1";

System\Text\RegularExpressions\RegexRunner.cs (2)

353_timeoutOccursAt = Environment.TickCount64 + _timeout; 362if (_checkTimeout && Environment.TickCount64 >= _timeoutOccursAt)

System\Text\RegularExpressions\Symbolic\SymbolicRegexMatcher.Automata.cs (1)

367if ((timeoutOccursAt != 0 && Environment.TickCount64 > timeoutOccursAt) || // if there's an active timer

System\Text\RegularExpressions\Symbolic\SymbolicRegexMatcher.cs (2)

341if (Environment.TickCount64 >= timeoutOccursAt) 364timeoutOccursAt = Environment.TickCount64 + _timeout;

System.Threading (7)

System\Threading\Barrier.cs (5)

329if (_actionCallerID != 0 && Environment.CurrentManagedThreadId == _actionCallerID) 428if (_actionCallerID != 0 && Environment.CurrentManagedThreadId == _actionCallerID) 653if (_actionCallerID != 0 && Environment.CurrentManagedThreadId == _actionCallerID) 789_actionCallerID = Environment.CurrentManagedThreadId; 927if (_actionCallerID != 0 && Environment.CurrentManagedThreadId == _actionCallerID)

System\Threading\ReaderWriterLock.cs (2)

30private static readonly int DefaultSpinCount = Environment.ProcessorCount != 1 ? 500 : 0; 1002int threadID = Environment.CurrentManagedThreadId;

System.Threading.Tasks.Dataflow (2)

Base\DataflowBlock.cs (1)

425if (!Environment.HasShutdownStarted)

Internal\DataflowEtwProvider.cs (1)

140try { exceptionData = string.Join(Environment.NewLine, completionTask.Exception!.InnerExceptions.Select(static e => e.ToString())); }

System.Threading.Tasks.Parallel (12)

System\Threading\Tasks\Parallel.cs (3)

884timeoutOccursAt - Environment.TickCount64 <= 0; 887Environment.TickCount64 + timeoutLength; 945Environment.ProcessorCount :

System\Threading\Tasks\Parallel.ForEachAsync.cs (8)

19/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 37/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 55/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 197/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 213/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 352/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 368/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 502private static int DefaultDegreeOfParallelism => Environment.ProcessorCount;

System\Threading\Tasks\TaskReplicator.cs (1)

166return 100 + Random.Shared.Next(0, 50 * Environment.ProcessorCount);

System.Transactions.Local (11)

System\Transactions\DtcProxyShim\DtcProxyShimFactory.cs (1)

38private static readonly int s_maxCachedInterfaces = Environment.ProcessorCount * 2;

System\Transactions\Oletx\OletxTransactionManager.cs (10)

152Environment.FailFast(SR.InternalError); 167Environment.FailFast(SR.InternalError); 187Environment.FailFast(SR.InternalError); 237Environment.FailFast(SR.InternalError); 254Environment.FailFast(SR.InternalError); 268Environment.FailFast(SR.InternalError); 282Environment.FailFast(SR.InternalError); 296Environment.FailFast(SR.InternalError); 315Environment.FailFast(SR.InternalError); 324Environment.FailFast(SR.InternalError);

System.Windows.Forms (29)

System\Resources\AssemblyNamesTypeResolutionService.cs (2)

17Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),

System\Windows\Forms\Accessibility\LabelEditAccessibleObject.cs (1)

35UIA_PROPERTY_ID.UIA_ProcessIdPropertyId => (VARIANT)Environment.ProcessId,

System\Windows\Forms\Accessibility\LabelEditNativeWindow.cs (2)

54(uint)Environment.ProcessId, 63(uint)Environment.ProcessId,

System\Windows\Forms\Application.cs (7)

160=> GetDataPath(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData)); 541=> GetDataPath(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)); 820=> GetDataPath(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)); 1463string[] arguments = Environment.GetCommandLineArgs();

System\Windows\Forms\Application.ThreadContext.cs (1)

621Environment.Exit(0);

System\Windows\Forms\Controls\ListView\ListViewItem.ListViewSubItem.ListViewSubItemAccessibleObject.cs (1)

126UIA_PROPERTY_ID.UIA_ProcessIdPropertyId => (VARIANT)Environment.ProcessId,

System\Windows\Forms\Controls\TextBox\TextBoxBase.cs (1)

647? string.Join(Environment.NewLine, value)

System\Windows\Forms\Controls\ToolStrips\ToolStripRenderer.cs (1)

1151if (Environment.OSVersion.Version >= new Version(10, 0, 22000)

System\Windows\Forms\Controls\WebBrowser\WebBrowser.cs (2)

612string mshtmlPath = Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.System), "mshtml.dll");

System\Windows\Forms\Dialogs\CommonDialogs\FolderBrowserDialog.cs (4)

24private Environment.SpecialFolder _rootFolder; 198[DefaultValue(Environment.SpecialFolder.Desktop)] 203public Environment.SpecialFolder RootFolder 260_rootFolder = Environment.SpecialFolder.Desktop;

System\Windows\Forms\Dialogs\CommonDialogs\SpecialFolderEnumConverter.cs (2)

29if (currentItem is Environment.SpecialFolder specialFolder && 30specialFolder.Equals(Environment.SpecialFolder.Personal))

System\Windows\Forms\Rendering\Animation\AnimationManager.cs (2)

41_threadId = Environment.CurrentManagedThreadId; 74if (Environment.CurrentManagedThreadId == _threadId)

System\Windows\Forms\SystemInformation.cs (3)

480public static string ComputerName => Environment.MachineName; 485public static string UserDomainName => Environment.UserDomainName; 524public static string UserName => Environment.UserName;

System.Windows.Forms.Design (10)

System\ComponentModel\Design\DesignerActionPanel.MethodLine.cs (1)

76ActionPanel.ShowError(string.Format(SR.DesignerActionPanel_ErrorInvokingAction, _methodItem!.DisplayName, Environment.NewLine + ex.Message));

System\ComponentModel\Design\Serialization\CodeDomDesignerLoader.cs (2)

350StringBuilder builder = new(Environment.NewLine); 351builder.AppendJoin(Environment.NewLine, failures);

System\Windows\Forms\Design\Behavior\BehaviorService.cs (2)

751snapLineInfo = string.Join(Environment.NewLine, _testHook_RecentSnapLines) + Environment.NewLine;

System\Windows\Forms\Design\ControlDesigner.cs (1)

2500stack = string.Join(Environment.NewLine, exceptionLines.Where(l => l.Contains(typeName)));

System\Windows\Forms\Design\FolderNameEditor.FolderBrowserFolder.cs (3)

10/// <see cref="Environment.SpecialFolder"/> is also a list of CSIDL values. Unfortunately CSIDL_CONNECTIONS, 12/// <see cref="Environment.GetFolderPath(Environment.SpecialFolder)"/>.

System\Windows\Forms\Design\StringCollectionEditor.StringCollectionForm.cs (1)

187=> _textEntry.Text = string.Join(Environment.NewLine, Items);

System.Windows.Forms.Primitives (14)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\Windows.Win32.IAdviseSinkEx.g.cs (6)

83 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 106 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 129 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 152 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 175 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 198 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex);

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\Windows.Win32.IMessageFilter.g.cs (3)

79 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 115 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 150 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex);

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\Windows.Win32.IRichEditOle.g.cs (2)

106 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex); 136 global::System.Environment.FailFast("COM object threw an exception from a non-HRESULT returning method.", ex);

System\Windows\Forms\Automation\UiaTextRange.cs (1)

791&& (text.Substring(lineStartIndex, lineTextLength) == Environment.NewLine

System\Windows\Forms\ObjectCache.cs (1)

19cacheSpace = Environment.Is64BitProcess ? 64 : 32;

Windows\Win32\UI\Shell\FolderBrowserHelper.cs (1)

27PInvoke.SHGetSpecialFolderLocation((int)Environment.SpecialFolder.Desktop, out rootFolderId);

System.Xaml (1)

System\Xaml\XamlSchemaContext.cs (1)

77if (_assemblyLoadHandler is not null && !Environment.HasShutdownStarted)

Terminals.Repl (2)

Program.cs (2)

13var resourceName = Environment.GetEnvironmentVariable("ASPIRE_RESOURCE_NAME") ?? "repl"; 14var processId = Environment.ProcessId.ToString(CultureInfo.InvariantCulture);

testhost (9)

parent\testhost.x86\TestHostTraceListener.cs (1)

43throw GetException((message + Environment.NewLine + detailMessage));

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

testhost.arm64 (9)

parent\testhost.x86\TestHostTraceListener.cs (1)

43throw GetException((message + Environment.NewLine + detailMessage));

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

testhost.x86 (9)

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

TestHostTraceListener.cs (1)

43throw GetException((message + Environment.NewLine + detailMessage));

TestProject.IntegrationServiceA (2)

Program.cs (2)

7string? skipResourcesValue = Environment.GetEnvironmentVariable("SKIP_RESOURCES"); 35app.MapGet("/pid", () => Environment.ProcessId);

TestProject.ServiceA (1)

Program.cs (1)

13app.MapGet("/pid", () => Environment.ProcessId);

TestProject.ServiceB (1)

Program.cs (1)

8app.MapGet("/pid", () => Environment.ProcessId);

TestProject.ServiceC (1)

Program.cs (1)

8app.MapGet("/pid", () => Environment.ProcessId);

UIAutomationClient (5)

MS\Internal\Automation\HwndProxyElementProvider.cs (3)

1614long dwTicks = (long)Environment.TickCount; 1617while (InMenuMode() && ((long)Environment.TickCount - dwTicks) < MenuTimeOut) 1747if (Environment.OSVersion.Version.Major >= 6)

MS\Internal\Automation\Misc.cs (1)

519&& System.Environment.OSVersion.Version.Major >= 6)

MS\Win32\UnsafeNativeMethods.cs (1)

175if (System.Environment.OSVersion.Version.Major >= 6)

UIAutomationClientSideProviders (32)

MS\Internal\AutomationProxies\Accessible.cs (2)

158if(Environment.OSVersion.Version.Major >= 6) 159wParam = new IntPtr(Environment.ProcessId);

MS\Internal\AutomationProxies\CommonGetThemePartSize.cs (1)

22if (Environment.OSVersion.Version.Major >= 5)

MS\Internal\AutomationProxies\CommonXSendMessage.cs (7)

625if (Environment.OSVersion.Version.Major == 5) 637if (Environment.OSVersion.Version.Major == 5) 649if (Environment.OSVersion.Version.Major == 5) 1486if (Environment.OSVersion.Version.Major > 5 || (Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor == 1)) 1508else if (Environment.OSVersion.Version.Major == 5)

MS\Internal\AutomationProxies\Misc.cs (8)

105long dwTicks = (long)Environment.TickCount; 108while (InMenuMode() && ((long)Environment.TickCount - dwTicks) < MenuTimeOut) 285bool result = (System.Environment.OSVersion.Version.Major >= 6) ? UnsafeNativeMethods.GetPhysicalCursorPos(ref pt) 1020&& System.Environment.OSVersion.Version.Major >= 6) 1210if (System.Environment.OSVersion.Version.Major >= 6) 1856if (Environment.OSVersion.Version.Major >= 6 && commonControlVersion >= 6) 1970Debug.Assert(System.Environment.OSVersion.Version.Major < 6); 2041Debug.Assert(System.Environment.OSVersion.Version.Major >= 6);

MS\Internal\AutomationProxies\SafeProcessHandle.cs (1)

23processId = (uint)Environment.ProcessId;

MS\Internal\AutomationProxies\WindowsButton.cs (3)

188if (Environment.OSVersion.Version.Major < 6) 288if (idEvent == InvokePattern.InvokedEvent && Environment.OSVersion.Version.Major >= 6) 555if (Environment.OSVersion.Version.Major >= 6)

MS\Internal\AutomationProxies\WindowsListView.cs (1)

907if (Environment.OSVersion.Version.Major < 6)

MS\Internal\AutomationProxies\WindowsMenu.cs (2)

812if ((Environment.OSVersion.Version.Major < 6) && (Misc.IsLayoutRTL(_hwnd))) 1256if ((Environment.OSVersion.Version.Major < 6) && (Misc.IsLayoutRTL(_hwnd)))

MS\Internal\AutomationProxies\WindowsScrollBar.cs (2)

159if ((Environment.OSVersion.Version.Major < 6) && (Misc.IsLayoutRTL(_parent._hwnd))) 585if ((Environment.OSVersion.Version.Major < 6) && (_sbFlag == NativeMethods.SB_HORZ) && (Misc.IsControlRTL(_parent._hwnd)))

MS\Internal\AutomationProxies\WindowsScrollBarBits.cs (2)

235if ((Environment.OSVersion.Version.Major < 6) && (Misc.IsLayoutRTL(parent._parent._hwnd))) 416if ((Environment.OSVersion.Version.Major < 6) && (Misc.IsLayoutRTL(hwnd)))

MS\Internal\AutomationProxies\WindowsTooltip.cs (1)

205if (System.Environment.OSVersion.Version.Major >= 6)

MS\Internal\AutomationProxies\WindowsTreeView.cs (1)

812if (_nativeAcc == null && System.Environment.OSVersion.Version.Major >= 6 && Misc.IsWindowInGivenProcess(_hwnd, "explorer"))

MS\Win32\UnsafeNativeMethods.cs (1)

314if (System.Environment.OSVersion.Version.Major >= 6)

vbc (14)

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

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

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

146var threadId = Environment.CurrentManagedThreadId; 148string output = prefix + message + Environment.NewLine;

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

58Environment.FailFast(message);

src\roslyn\src\Compilers\Shared\StandardBuildEnvironment.cs (3)

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

18: base(VisualBasicCommandLineParser.Default, responseFile, args, buildPaths, Environment.GetEnvironmentVariable("LIB"), analyzerLoader)

VBCSCompiler (16)

src\roslyn\src\Compilers\Server\VBCSCompiler\ClientConnectionHandler.cs (1)

85if (!Environment.Is64BitProcess && !MemoryHelper.IsMemoryAvailable(Logger))

src\roslyn\src\Compilers\Server\VBCSCompiler\CompilationCache.cs (1)

278logger.Log($"Cache miss {dllName} [{hashKey}] diff vs entry [{entryName}]:{Environment.NewLine}{diff}");

src\roslyn\src\Compilers\Server\VBCSCompiler\NamedPipeClientConnectionHost.cs (1)

69var listenCount = Math.Min(4, Environment.ProcessorCount);

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

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

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

146var threadId = Environment.CurrentManagedThreadId; 148string output = prefix + message + Environment.NewLine;

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

58Environment.FailFast(message);

src\roslyn\src\Compilers\Shared\StandardBuildEnvironment.cs (3)

vstest.console (95)

CommandLine\Executor.cs (3)

97var additionalThreadsCount = Environment.ProcessorCount * 4; 179var diag = Environment.GetEnvironmentVariable("VSTEST_DIAG"); 181var diagVerbosity = Environment.GetEnvironmentVariable("VSTEST_DIAG_VERBOSITY");

Internal\ConsoleLogger.cs (2)

279var prefix = string.Format(CultureInfo.CurrentCulture, "{0}{1}", Environment.NewLine, TestMessageFormattingPrefix); 280var messageText = message.Text?.Replace(Environment.NewLine, prefix).TrimEnd(TestMessageFormattingPrefix.ToCharArray());

Internal\MSBuildLogger.cs (5)

191var stackFrames = Regex.Split(result.ErrorStackTrace, Environment.NewLine); 361var prefix = string.Format(CultureInfo.CurrentCulture, "{0}{1}", Environment.NewLine, testMessageFormattingPrefix); 362var messageText = message.Text?.Replace(Environment.NewLine, prefix).TrimEnd(testMessageFormattingPrefix.ToCharArray()); 433string[] stackFrames = Regex.Split(errorStackTrace, Environment.NewLine); 491MethodInfo? getResourceStringMethod = typeof(Environment).GetMethod("GetResourceString", BindingFlags.Static | BindingFlags.NonPublic, null, [typeof(string)], null);

Processors\EnableCodeCoverageArgumentProcessor.cs (71)

Processors\RunSpecificTestsArgumentProcessor.cs (1)

221if (Environment.GetEnvironmentVariable("VSTEST_MSBUILD_NOLOGO") != "1")

Processors\RunTestsArgumentProcessor.cs (1)

153if (Environment.GetEnvironmentVariable("VSTEST_MSBUILD_NOLOGO") != "1")

Processors\TestAdapterLoadingStrategyArgumentProcessor.cs (1)

217var testAdapterPath = _fileHelper.GetFullPath(Environment.ExpandEnvironmentVariables(adapterPath));

Publisher\MetricsPublisherFactory.cs (1)

22var logEnabled = Environment.GetEnvironmentVariable("VSTEST_LOGTELEMETRY");

Publisher\TextFileTelemetryPublisher.cs (1)

60string resultDirectory = Environment.GetEnvironmentVariable("VSTEST_LOGTELEMETRY_PATH")

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

TestPlatformHelpers\TestRequestManager.cs (1)

1339=> Environment.GetEnvironmentVariable("VSTEST_TELEMETRY_OPTEDIN")?.Equals("1", StringComparison.Ordinal) == true;

vstest.console.arm64 (95)

parent\vstest.console\CommandLine\Executor.cs (3)

parent\vstest.console\Internal\ConsoleLogger.cs (2)

parent\vstest.console\Internal\MSBuildLogger.cs (5)

parent\vstest.console\Processors\EnableCodeCoverageArgumentProcessor.cs (71)

parent\vstest.console\Processors\RunSpecificTestsArgumentProcessor.cs (1)

221if (Environment.GetEnvironmentVariable("VSTEST_MSBUILD_NOLOGO") != "1")

parent\vstest.console\Processors\RunTestsArgumentProcessor.cs (1)

153if (Environment.GetEnvironmentVariable("VSTEST_MSBUILD_NOLOGO") != "1")

parent\vstest.console\Processors\TestAdapterLoadingStrategyArgumentProcessor.cs (1)

217var testAdapterPath = _fileHelper.GetFullPath(Environment.ExpandEnvironmentVariables(adapterPath));

parent\vstest.console\Publisher\MetricsPublisherFactory.cs (1)

22var logEnabled = Environment.GetEnvironmentVariable("VSTEST_LOGTELEMETRY");

parent\vstest.console\Publisher\TextFileTelemetryPublisher.cs (1)

60string resultDirectory = Environment.GetEnvironmentVariable("VSTEST_LOGTELEMETRY_PATH")

parent\vstest.console\TestPlatformHelpers\TestRequestManager.cs (1)

1339=> Environment.GetEnvironmentVariable("VSTEST_TELEMETRY_OPTEDIN")?.Equals("1", StringComparison.Ordinal) == true;

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

WithDockerfile.AppHost (1)

AppHost.cs (1)

44var baseImage = Environment.GetEnvironmentVariable("BASE_IMAGE") ?? "mcr.microsoft.com/oss/go/microsoft/golang:1.23";