Add -e option to dotnet run

src/Cli/dotnet/CommonOptions.cs

@@ -276,6 +276,31 @@ internal static CliArgument<T> AddCompletions<T>(this CliArgument<T> argument, F
             argument.CompletionSources.Add(completionSource);
             return argument;
         }
+
+        internal static IEnumerable<(string name, string value)> GetEnvironmentVariables(ParseResult parseResult)
+        {
+            CliOption<IEnumerable<string>> option = EnvOption;
+
+            if (parseResult.GetResult(option) is null)
+            {
+                yield break;
+            }
+
+            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);
+                }
+
+                yield return (name, value);
+            }
+        }
     }
 
     public enum VerbosityOptions

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

@@ -61,8 +61,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: [.. CommonOptions.GetEnvironmentVariables(parseResult)]
             );
 
             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, in the listed order.
+        /// </summary>
+        public IReadOnlyList<(string name, string value)> 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,
+            IReadOnlyList<(string name, string value)> 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/Program.cs

@@ -228,8 +228,11 @@ 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
+            foreach (var (name, value) in CommonOptions.GetEnvironmentVariables(result))
+            {
+                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 +306,6 @@ private static bool ContainsBuiltTestSources(string[] args)
             return false;
         }
 
-        private static void SetEnvironmentVariablesFromParameters(TestCommand testCommand, ParseResult parseResult)
-        {
-            CliOption<IEnumerable<string>> option = CommonOptions.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)
         {