Add -e option to dotnet run (#45795)

src/Cli/dotnet/CommonLocalizableStrings.resx

@@ -698,6 +698,25 @@ setx PATH "%PATH%;{0}"
   <data name="CannotSpecifyBothRuntimeAndOsOptions" xml:space="preserve">
     <value>Specifying both the `-r|--runtime` and `-os` options is not supported.</value>
   </data>
+  <data name="CmdEnvironmentVariableDescription" xml:space="preserve">
+    <value>Sets the value of an environment variable. 
+Creates the variable if it does not exist, overrides if it does. 
+This will force the tests to be run in an isolated process. 
+This argument can be specified multiple times to provide multiple variables.
+
+Examples:
+-e VARIABLE=abc
+-e VARIABLE="value with spaces"
+-e VARIABLE="value;seperated with;semicolons"
+-e VAR1=abc -e VAR2=def -e VAR3=ghi
+</value>
+  </data>
+  <data name="CmdEnvironmentVariableExpression" xml:space="preserve">
+    <value>NAME="VALUE"</value>
+  </data>
+  <data name="IncorrectlyFormattedEnvironmentVariables" xml:space="preserve">
+    <value>Incorrectly formatted environment variables: {0}</value>
+  </data>
   <data name="SelfContainedOptionDescription" xml:space="preserve">
     <value>Publish the .NET runtime with your application so the runtime doesn't need to be installed on the target machine.
 The default is 'false.' However, when targeting .NET 7 or lower, the default is 'true' if a runtime identifier is specified.</value>

src/Cli/dotnet/CommonOptions.cs

@@ -3,6 +3,7 @@
 
 using System.CommandLine;
 using System.CommandLine.Completions;
+using System.CommandLine.Parsing;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools;
 using Microsoft.DotNet.Tools.Common;
@@ -174,6 +175,52 @@ internal static string ArchOptionValue(ParseResult parseResult) =>
             // Flip the argument so that if this option is specified we get selfcontained=false
             .SetForwardingFunction((arg, p) => ForwardSelfContainedOptions(!arg, p));
 
+        public static readonly CliOption<IReadOnlyDictionary<string, string>> EnvOption = new("--environment", "-e")
+        {
+            Description = CommonLocalizableStrings.CmdEnvironmentVariableDescription,
+            HelpName = CommonLocalizableStrings.CmdEnvironmentVariableExpression,
+            CustomParser = ParseEnvironmentVariables,
+            // Can't allow multiple arguments because the separator needs to be parsed as part of the environment variable value.
+            AllowMultipleArgumentsPerToken = false
+        };
+
+        private static IReadOnlyDictionary<string, string> ParseEnvironmentVariables(ArgumentResult argumentResult)
+        {
+            var result = new Dictionary<string, string>(
+                RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
+
+            List<CliToken>? invalid = null;
+
+            foreach (var token in argumentResult.Tokens)
+            {
+                var separator = token.Value.IndexOf('=');
+                var (name, value) = (separator >= 0)
+                    ? (token.Value[0..separator], token.Value[(separator + 1)..])
+                    : (token.Value, "");
+
+                name = name.Trim();
+
+                if (name != "")
+                {
+                    result[name] = value;
+                }
+                else
+                {
+                    invalid ??= [];
+                    invalid.Add(token);
+                }
+            }
+
+            if (invalid != null)
+            {
+                argumentResult.AddError(string.Format(
+                    CommonLocalizableStrings.IncorrectlyFormattedEnvironmentVariables,
+                    string.Join(", ", invalid.Select(x => $"'{x.Value}'"))));
+            }
+
+            return result;
+        }
+
         public static readonly CliOption<string> TestPlatformOption = new("--Platform");
 
         public static readonly CliOption<string> TestFrameworkOption = new("--Framework");
@@ -259,13 +306,6 @@ private static IEnumerable<string> ForwardSelfContainedOptions(bool isSelfContai
             return selfContainedProperties;
         }
 
-        private static bool UserSpecifiedRidOption(ParseResult parseResult) =>
-            (parseResult.GetResult(RuntimeOption) ??
-            parseResult.GetResult(LongFormRuntimeOption) ??
-            parseResult.GetResult(ArchitectureOption) ??
-            parseResult.GetResult(LongFormArchitectureOption) ??
-            parseResult.GetResult(OperatingSystemOption)) is not null;
-
         internal static CliOption<T> AddCompletions<T>(this CliOption<T> option, Func<CompletionContext, IEnumerable<CompletionItem>> completionSource)
         {
             option.CompletionSources.Add(completionSource);

src/Cli/dotnet/Properties/launchSettings.json

@@ -1,7 +1,9 @@
 {
   "profiles": {
     "dotnet": {
-      "commandName": "Project"
+      "commandName": "Project",
+      "commandLineArgs": "run -e MyCoolEnvironmentVariableKey=OverriddenEnvironmentVariableValue",
+      "workingDirectory": "C:\\sdk5\\artifacts\\tmp\\Debug\\EnvOptionLaun---86C8BD0D"
     }
   }
-}
+}

src/Cli/dotnet/commands/dotnet-run/Program.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Immutable;
 using System.CommandLine;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.Utils;
@@ -61,8 +62,9 @@ public static RunCommand FromParseResult(ParseResult parseResult)
                 noRestore: parseResult.HasOption(RunCommandParser.NoRestoreOption) || parseResult.HasOption(RunCommandParser.NoBuildOption),
                 interactive: parseResult.HasOption(RunCommandParser.InteractiveOption),
                 verbosity: parseResult.HasOption(CommonOptions.VerbosityOption) ? parseResult.GetValue(CommonOptions.VerbosityOption) : null,
-                restoreArgs: restoreArgs.ToArray(),
-                args: nonBinLogArgs.ToArray()
+                restoreArgs: [.. restoreArgs],
+                args: [.. nonBinLogArgs],
+                environmentVariables: parseResult.GetValue(CommonOptions.EnvOption) ?? ImmutableDictionary<string, string>.Empty
             );
 
             return command;

src/Cli/dotnet/commands/dotnet-run/RunCommand.cs

@@ -28,6 +28,11 @@ private record RunProperties(string? RunCommand, string? RunArguments, string? R
         public bool Interactive { get; private set; }
         public string[] RestoreArgs { get; private set; }
 
+        /// <summary>
+        /// Environment variables specified on command line via -e option.
+        /// </summary>
+        public IReadOnlyDictionary<string, string> EnvironmentVariables { get; private set; }
+
         private bool ShouldBuild => !NoBuild;
 
         public string LaunchProfile { get; private set; }
@@ -43,7 +48,8 @@ public RunCommand(
             bool interactive,
             VerbosityOptions? verbosity,
             string[] restoreArgs,
-            string[] args)
+            string[] args,
+            IReadOnlyDictionary<string, string> environmentVariables)
         {
             NoBuild = noBuild;
             ProjectFileFullPath = DiscoverProjectFilePath(projectFileOrDirectory);
@@ -54,6 +60,7 @@ public RunCommand(
             NoRestore = noRestore;
             Verbosity = verbosity;
             RestoreArgs = GetRestoreArguments(restoreArgs);
+            EnvironmentVariables = environmentVariables;
         }
 
         public int Execute()
@@ -76,10 +83,18 @@ public int Execute()
             try
             {
                 ICommand targetCommand = GetTargetCommand();
-                var launchSettingsCommand = ApplyLaunchSettingsProfileToCommand(targetCommand, launchSettings);
+                ApplyLaunchSettingsProfileToCommand(targetCommand, launchSettings);
+
+                // Env variables specified on command line override those specified in launch profile:
+                foreach (var (name, value) in EnvironmentVariables)
+                {
+                    targetCommand.EnvironmentVariable(name, value);
+                }
+
                 // Ignore Ctrl-C for the remainder of the command's execution
                 Console.CancelKeyPress += (sender, e) => { e.Cancel = true; };
-                return launchSettingsCommand.Execute().ExitCode;
+
+                return targetCommand.Execute().ExitCode;
             }
             catch (InvalidProjectFileException e)
             {
@@ -89,29 +104,31 @@ public int Execute()
             }
         }
 
-        private ICommand ApplyLaunchSettingsProfileToCommand(ICommand targetCommand, ProjectLaunchSettingsModel? launchSettings)
+        private void ApplyLaunchSettingsProfileToCommand(ICommand targetCommand, ProjectLaunchSettingsModel? launchSettings)
         {
-            if (launchSettings != null)
+            if (launchSettings == null)
             {
-                if (!string.IsNullOrEmpty(launchSettings.ApplicationUrl))
-                {
-                    targetCommand.EnvironmentVariable("ASPNETCORE_URLS", launchSettings.ApplicationUrl);
-                }
+                return;
+            }
 
-                targetCommand.EnvironmentVariable("DOTNET_LAUNCH_PROFILE", launchSettings.LaunchProfileName);
+            if (!string.IsNullOrEmpty(launchSettings.ApplicationUrl))
+            {
+                targetCommand.EnvironmentVariable("ASPNETCORE_URLS", launchSettings.ApplicationUrl);
+            }
 
-                foreach (var entry in launchSettings.EnvironmentVariables)
-                {
-                    string value = Environment.ExpandEnvironmentVariables(entry.Value);
-                    //NOTE: MSBuild variables are not expanded like they are in VS
-                    targetCommand.EnvironmentVariable(entry.Key, value);
-                }
-                if (string.IsNullOrEmpty(targetCommand.CommandArgs) && launchSettings.CommandLineArgs != null)
-                {
-                    targetCommand.SetCommandArgs(launchSettings.CommandLineArgs);
-                }
+            targetCommand.EnvironmentVariable("DOTNET_LAUNCH_PROFILE", launchSettings.LaunchProfileName);
+
+            foreach (var entry in launchSettings.EnvironmentVariables)
+            {
+                string value = Environment.ExpandEnvironmentVariables(entry.Value);
+                //NOTE: MSBuild variables are not expanded like they are in VS
+                targetCommand.EnvironmentVariable(entry.Key, value);
+            }
+
+            if (string.IsNullOrEmpty(targetCommand.CommandArgs) && launchSettings.CommandLineArgs != null)
+            {
+                targetCommand.SetCommandArgs(launchSettings.CommandLineArgs);
             }
-            return targetCommand;
         }
 
         private bool TryGetLaunchProfileSettingsIfNeeded(out ProjectLaunchSettingsModel? launchSettingsModel)

src/Cli/dotnet/commands/dotnet-run/RunCommandParser.cs

@@ -81,6 +81,7 @@ private static CliCommand ConstructCommand()
             command.Options.Add(CommonOptions.OperatingSystemOption);
             command.Options.Add(CommonOptions.DisableBuildServersOption);
             command.Options.Add(CommonOptions.ArtifactsPathOption);
+            command.Options.Add(CommonOptions.EnvOption);
 
             command.Arguments.Add(ApplicationArguments);
 

src/Cli/dotnet/commands/dotnet-test/LocalizableStrings.resx

@@ -269,22 +269,6 @@ For MSTest before 2.2.4, the timeout is used for all testcases.</value>
   <data name="HangTimeoutArgumentName" xml:space="preserve">
     <value>TIMESPAN</value>
   </data>
-  <data name="CmdEnvironmentVariableDescription" xml:space="preserve">
-    <value>Sets the value of an environment variable. 
-Creates the variable if it does not exist, overrides if it does. 
-This will force the tests to be run in an isolated process. 
-This argument can be specified multiple times to provide multiple variables.
-
-Examples:
--e VARIABLE=abc
--e VARIABLE="value with spaces"
--e VARIABLE="value;seperated with;semicolons"
--e VAR1=abc -e VAR2=def -e VAR3=ghi
-</value>
-  </data>
-  <data name="CmdEnvironmentVariableExpression" xml:space="preserve">
-    <value>NAME="VALUE"</value>
-  </data>
   <data name="NoSerializerRegisteredWithIdErrorMessage" xml:space="preserve">
       <value>No serializer registered with ID '{0}'</value>
   </data>

src/Cli/dotnet/commands/dotnet-test/Program.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Immutable;
 using System.CommandLine;
 using System.Runtime.Versioning;
 using System.Text.RegularExpressions;
@@ -228,8 +229,14 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
                 noRestore,
                 msbuildPath);
 
-            // Apply environment variables provided by the user via --environment (-e) parameter, if present
-            SetEnvironmentVariablesFromParameters(testCommand, result);
+            // Apply environment variables provided by the user via --environment (-e) option, if present
+            if (result.GetValue(CommonOptions.EnvOption) is { } environmentVariables)
+            {
+                foreach (var (name, value) in environmentVariables)
+                {
+                    testCommand.EnvironmentVariable(name, value);
+                }
+            }
 
             // Set DOTNET_PATH if it isn't already set in the environment as it is required
             // by the testhost which uses the apphost feature (Windows only).
@@ -303,31 +310,6 @@ private static bool ContainsBuiltTestSources(string[] args)
             return false;
         }
 
-        private static void SetEnvironmentVariablesFromParameters(TestCommand testCommand, ParseResult parseResult)
-        {
-            CliOption<IEnumerable<string>> option = TestCommandParser.EnvOption;
-
-            if (parseResult.GetResult(option) is null)
-            {
-                return;
-            }
-
-            foreach (string env in parseResult.GetValue(option))
-            {
-                string name = env;
-                string value = string.Empty;
-
-                int equalsIndex = env.IndexOf('=');
-                if (equalsIndex > 0)
-                {
-                    name = env.Substring(0, equalsIndex);
-                    value = env.Substring(equalsIndex + 1);
-                }
-
-                testCommand.EnvironmentVariable(name, value);
-            }
-        }
-
         /// <returns>A case-insensitive dictionary of any properties passed from the user and their values.</returns>
         private static Dictionary<string, string> GetUserSpecifiedExplicitMSBuildProperties(ParseResult parseResult)
         {

src/Cli/dotnet/commands/dotnet-test/TestCommandParser.cs

@@ -32,12 +32,6 @@ internal static class TestCommandParser
             Description = LocalizableStrings.CmdListTestsDescription
         }.ForwardAs("-property:VSTestListTests=true");
 
-        public static readonly CliOption<IEnumerable<string>> EnvOption = new CliOption<IEnumerable<string>>("--environment", "-e")
-        {
-            Description = LocalizableStrings.CmdEnvironmentVariableDescription,
-            HelpName = LocalizableStrings.CmdEnvironmentVariableExpression
-        }.AllowSingleArgPerToken();
-
         public static readonly CliOption<string> FilterOption = new ForwardedOption<string>("--filter")
         {
             Description = LocalizableStrings.CmdTestCaseFilterDescription,
@@ -219,7 +213,7 @@ private static CliCommand GetVSTestCliCommand()
 
             command.Options.Add(SettingsOption);
             command.Options.Add(ListTestsOption);
-            command.Options.Add(EnvOption);
+            command.Options.Add(CommonOptions.EnvOption);
             command.Options.Add(FilterOption);
             command.Options.Add(AdapterOption);
             command.Options.Add(LoggerOption);