[dotnet-run] Implement DeployToDevice target invocation

Context: dotnet/android#10631

Add support for calling the `DeployToDevice` MSBuild target during
`dotnet run`. The target is invoked after the build step (or with
--no-build) to enable deployment to physical devices or emulators.

- Create `RunCommandSelector` once per run for framework/device
  selection and deployment

- Call `DeployToDevice` target if it exists in the project

- Reuse cached `ProjectInstance` for performance

- Add localized message for deployment failures

- Added tests

Author: jonathanpeppers

src/Cli/Microsoft.DotNet.Cli.Utils/Constants.cs

@@ -30,6 +30,7 @@ public static class Constants
     public const string Build = nameof(Build);
     public const string ComputeRunArguments = nameof(ComputeRunArguments);
     public const string ComputeAvailableDevices = nameof(ComputeAvailableDevices);
+    public const string DeployToDevice = nameof(DeployToDevice);
     public const string CoreCompile = nameof(CoreCompile);
 
     // MSBuild item metadata

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -1717,6 +1717,9 @@ The default is to publish a framework-dependent application.</value>
   <data name="RunCommandException" xml:space="preserve">
     <value>The build failed. Fix the build errors and run again.</value>
   </data>
+  <data name="RunCommandDeployFailed" xml:space="preserve">
+    <value>Deployment to device failed. Fix any deployment errors and run again.</value>
+  </data>
   <data name="RunCommandExceptionCouldNotApplyLaunchSettings" xml:space="preserve">
     <value>The launch profile "{0}" could not be applied.
 {1}</value>

src/Cli/dotnet/Commands/Run/RunCommand.cs

@@ -148,10 +148,20 @@ public int Execute()
         FacadeLogger? logger = ProjectFileFullPath is not null 
             ? LoggerUtility.DetermineBinlogger([.. MSBuildArgs.OtherMSBuildArgs], "dotnet-run")
             : null;
+
+        // Create selector for project-based runs to handle framework/device selection and deploy
+        using var selector = ProjectFileFullPath is not null
+            ? new RunCommandSelector(
+                ProjectFileFullPath,
+                MSBuildArgs,
+                Interactive,
+                logger)
+            : null;
+
         try
         {
             // Pre-run evaluation: Handle target framework and device selection for project-based scenarios
-            if (ProjectFileFullPath is not null && !TrySelectTargetFrameworkAndDeviceIfNeeded(logger))
+            if (selector is not null && !TrySelectTargetFrameworkAndDeviceIfNeeded(selector))
             {
                 // If --list-devices was specified, this is a successful exit
                 return ListDevices ? 0 : 1;
@@ -194,6 +204,17 @@ public int Execute()
                 }
             }
 
+            // Deploy step: Call DeployToDevice target if available
+            // This must run even with --no-build, as the user may have selected a different device
+            if (selector is not null && !selector.TryDeployToDevice())
+            {
+                // Only error if we have a valid project (not a .sln file, etc.)
+                if (selector.HasValidProject)
+                {
+                    throw new GracefulException(CliCommandStrings.RunCommandDeployFailed);
+                }
+            }
+
             ICommand targetCommand = GetTargetCommand(projectFactory, cachedRunProperties, logger);
             ApplyLaunchSettingsProfileToCommand(targetCommand, launchSettings);
 
@@ -228,11 +249,11 @@ public int Execute()
     /// Uses a single RunCommandSelector instance for both operations, re-evaluating
     /// the project after framework selection to get the correct device list.
     /// </summary>
-    /// <param name="logger">Optional logger for MSBuild operations (device selection)</param>
+    /// <param name="selector">The selector to use for framework and device selection</param>
     /// <returns>True if we can continue, false if we should exit</returns>
-    private bool TrySelectTargetFrameworkAndDeviceIfNeeded(FacadeLogger? logger)
+    private bool TrySelectTargetFrameworkAndDeviceIfNeeded(RunCommandSelector selector)
     {
-        Debug.Assert(ProjectFileFullPath is not null);
+        Debug.Assert(selector is not null);
 
         var globalProperties = CommonRunHelpers.GetGlobalPropertiesFromArgs(MSBuildArgs);
 
@@ -246,19 +267,16 @@ private bool TrySelectTargetFrameworkAndDeviceIfNeeded(FacadeLogger? logger)
         }
 
         // Optimization: If BOTH framework AND device are already specified (and we're not listing devices), 
-        // we can skip both framework selection and device selection entirely
+        // we can skip device selection UI
         bool hasFramework = globalProperties.TryGetValue("TargetFramework", out var existingFramework) && !string.IsNullOrWhiteSpace(existingFramework);
         bool hasDevice = globalProperties.TryGetValue("Device", out var preSpecifiedDevice) && !string.IsNullOrWhiteSpace(preSpecifiedDevice);
 
         if (!ListDevices && hasFramework && hasDevice)
         {
-            // Both framework and device are pre-specified, no need to create selector or logger
+            // Both framework and device are pre-specified, skip device selection UI
             return true;
         }
 
-        // Create a single selector for both framework and device selection
-        using var selector = new RunCommandSelector(ProjectFileFullPath, globalProperties, Interactive, logger);
-        
         // Step 1: Select target framework if needed
         if (!selector.TrySelectTargetFramework(out string? selectedFramework))
         {

src/Cli/dotnet/Commands/Run/RunCommandSelector.cs

@@ -6,6 +6,7 @@
 using Microsoft.Build.Evaluation;
 using Microsoft.Build.Exceptions;
 using Microsoft.Build.Execution;
+using Microsoft.Build.Framework;
 using Microsoft.DotNet.Cli.Utils;
 using Spectre.Console;
 
@@ -25,26 +26,34 @@ internal sealed class RunCommandSelector : IDisposable
     private readonly string _projectFilePath;
     private readonly Dictionary<string, string> _globalProperties;
     private readonly FacadeLogger? _binaryLogger;
+    private readonly ILogger? _consoleLogger;
     private readonly bool _isInteractive;
 
     private ProjectCollection? _collection;
     private Microsoft.Build.Evaluation.Project? _project;
     private ProjectInstance? _projectInstance;
 
+    /// <summary>
+    /// Gets whether the selector has a valid project that can be evaluated.
+    /// This is false for .sln files or other invalid project files.
+    /// </summary>
+    public bool HasValidProject { get; private set; }
+
     /// <param name="projectFilePath">Path to the project file to evaluate</param>
-    /// <param name="globalProperties">Global MSBuild properties to use during evaluation</param>
+    /// <param name="msbuildArgs">MSBuild arguments containing properties and verbosity settings</param>
     /// <param name="isInteractive">Whether to prompt the user for selections</param>
     /// <param name="binaryLogger">Optional binary logger for MSBuild operations. The logger will not be disposed by this class.</param>
     public RunCommandSelector(
         string projectFilePath,
-        Dictionary<string, string> globalProperties,
+        MSBuildArgs msbuildArgs,
         bool isInteractive,
         FacadeLogger? binaryLogger = null)
     {
         _projectFilePath = projectFilePath;
-        _globalProperties = globalProperties;
+        _globalProperties = CommonRunHelpers.GetGlobalPropertiesFromArgs(msbuildArgs);
         _isInteractive = isInteractive;
         _binaryLogger = binaryLogger;
+        _consoleLogger = CommonRunHelpers.GetConsoleLogger(msbuildArgs);
     }
 
     /// <summary>
@@ -101,6 +110,7 @@ public void InvalidateGlobalProperties(Dictionary<string, string> updatedPropert
         _projectInstance = null;
         _collection?.Dispose();
         _collection = null;
+        HasValidProject = false;
     }
 
     /// <summary>
@@ -124,12 +134,14 @@ private bool OpenProjectIfNeeded([NotNullWhen(true)] out ProjectInstance? projec
             _project = _collection.LoadProject(_projectFilePath);
             _projectInstance = _project.CreateProjectInstance();
             projectInstance = _projectInstance;
+            HasValidProject = true;
             return true;
         }
         catch (InvalidProjectFileException)
         {
             // Invalid project file, return false
             projectInstance = null;
+            HasValidProject = false;
             return false;
         }
     }
@@ -237,7 +249,7 @@ public bool TryComputeAvailableDevices(out List<DeviceItem>? devices)
         // Build the target
         var buildResult = projectInstance.Build(
             targets: [Constants.ComputeAvailableDevices],
-            loggers: _binaryLogger is null ? null : [_binaryLogger],
+            loggers: GetLoggers(),
             remoteLoggers: null,
             out var targetOutputs);
 
@@ -433,4 +445,45 @@ public bool TrySelectDevice(
             return null;
         }
     }
+
+    /// <summary>
+    /// Attempts to deploy to a device by calling the DeployToDevice MSBuild target if it exists.
+    /// This reuses the already-loaded project instance for performance.
+    /// </summary>
+    /// <returns>True if deployment succeeded or was skipped (no target), false if deployment failed</returns>
+    public bool TryDeployToDevice()
+    {
+        if (!OpenProjectIfNeeded(out var projectInstance))
+        {
+            // Invalid project file
+            return false;
+        }
+
+        // Check if the DeployToDevice target exists in the project
+        if (!projectInstance.Targets.ContainsKey(Constants.DeployToDevice))
+        {
+            // Target doesn't exist, skip deploy step
+            return true;
+        }
+
+        // Build the DeployToDevice target
+        var buildResult = projectInstance.Build(
+            targets: [Constants.DeployToDevice],
+            loggers: GetLoggers(),
+            remoteLoggers: null,
+            out _);
+
+        return buildResult;
+    }
+
+    /// <summary>
+    /// Gets the list of loggers to use for MSBuild operations.
+    /// </summary>
+    private IEnumerable<ILogger> GetLoggers()
+    {
+        if (_binaryLogger is not null)
+            yield return _binaryLogger;
+        if (_consoleLogger is not null)
+            yield return _consoleLogger;
+    }
 }