[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,
+                CommonRunHelpers.GetGlobalPropertiesFromArgs(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,13 @@ 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())
+            {
+                throw new GracefulException(CliCommandStrings.RunCommandDeployFailed);
+            }
+
             ICommand targetCommand = GetTargetCommand(projectFactory, cachedRunProperties, logger);
             ApplyLaunchSettingsProfileToCommand(targetCommand, launchSettings);
 
@@ -228,11 +245,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 +263,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

@@ -433,4 +433,34 @@ 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: _binaryLogger is null ? null : [_binaryLogger],
+            remoteLoggers: null,
+            out _);
+
+        return buildResult;
+    }
 }