Enhance support for file-based apps and optimize AppHost SDK

- Modified Sdk.in.props to auto-import Microsoft.NET.Sdk
- Refined Sdk.in.targets to streamline implicit references and removed workaround  targets for file-based apps no longer needed as of rc.2.
- Introduced CSharpAppResource class to represent C# projects or file-based apps which doesn't suppress build of the project.
- Updated DcpExecutor to handle file-based apps with appropriate run commands.
- Enhanced IProjectMetadata to include suppress build functionality.
- Improved ProjectResourceBuilderExtensions to support adding C# projects or file-based apps.
- Updated project templates to reflect changes in SDK references.
- Added unit tests for resource icon resolution to cover file extensions.

Author: DamianEdwards

playground/FileBasedApps/Directory.Build.targets

@@ -4,6 +4,10 @@
     <AspireProjectOrPackageReference Include="Aspire.Hosting.AppHost" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Include="..\KnownResourceNames.cs" Link="KnownResourceNames.cs" />
+  </ItemGroup>
+
   <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.targets', '$(MSBuildThisFileDirectory)../'))" />
 
 </Project>

playground/FileBasedApps/apphost.cs

@@ -5,4 +5,14 @@
 
 builder.AddCSharpApp("api", "api.cs");
 
+#if !SKIP_DASHBOARD_REFERENCE
+// This project is only added in playground projects to support development/debugging
+// of the dashboard. It is not required in end developer code. Comment out this code
+// or build with `/p:SkipDashboardReference=true`, to test end developer
+// dashboard launch experience, Refer to Directory.Build.props for the path to
+// the dashboard binary (defaults to the Aspire.Dashboard bin output in the
+// artifacts dir).
+builder.AddProject<Projects.Aspire_Dashboard>(KnownResourceNames.AspireDashboard);
+#endif
+
 builder.Build().Run();

src/Aspire.AppHost.Sdk/SDK/Sdk.in.props

@@ -4,17 +4,18 @@
     <!-- Do not import the workload targets as this project is instead using the Aspire.AppHost.Sdk -->
     <SkipAspireWorkloadManifest>true</SkipAspireWorkloadManifest>
     <IsAspireHost>true</IsAspireHost>
+    <!-- Auto-import the Microsoft.NET.Sdk if not already imported -->
+    <_ImportMicrosoftNETSdkFromAspireSdk Condition=" '$(UsingMicrosoftNETSdk)' == '' ">true</_ImportMicrosoftNETSdkFromAspireSdk>
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(FileBasedProgram)' == 'true' ">
+    <!-- Disable AOT and Trimming for file-based apps -->
     <PublishAot>false</PublishAot>
-    <PublishTrimmed>false</PublishTrimmed>
+    <!-- <PublishTrimmed>false</PublishTrimmed>
     <EnableAotAnalyzer>false</EnableAotAnalyzer>
     <EnableTrimAnalyzer>false</EnableTrimAnalyzer>
-    <EnableSingleFileAnalyzer>false</EnableSingleFileAnalyzer>
-    <_ImportMicrosoftNETSdkFromAspireSdk Condition=" '$(UsingMicrosoftNETSdk)' == '' ">true</_ImportMicrosoftNETSdkFromAspireSdk>
-    <_ForceAspireFileBasedAppHostDefaults Condition=" '$(IsAspireHost)' == 'true' ">true</_ForceAspireFileBasedAppHostDefaults>
+    <EnableSingleFileAnalyzer>false</EnableSingleFileAnalyzer> -->
   </PropertyGroup>
 
   <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" Condition=" '$(_ImportMicrosoftNETSdkFromAspireSdk)' == 'true' " />
-</Project>
+</Project>

src/Aspire.AppHost.Sdk/SDK/Sdk.in.targets

@@ -51,26 +51,10 @@
     <AspireRidToolExecutable>$(AspireRidToolDirectory)Aspire.RuntimeIdentifier.Tool.dll</AspireRidToolExecutable>
   </PropertyGroup>
 
-  <!-- If the AppHost is a file-based app, then force disable AOT and Trimming.
-       This can be removed once https://github.com/dotnet/sdk/pull/50885 is merged and flows through to .NET 10 SDK as the values set in Sdk.props will be sufficient. -->
-  <Target Name="DisablePublishAotForAspireHost" BeforeTargets="_ComputeToolPackInputsToProcessFrameworkReferences;_CollectTargetFrameworkForTelemetry;ProcessFrameworkReferences;Restore;CollectPackageReferences"
-          Condition="'$(_ForceAspireFileBasedAppHostDefaults)' == 'true'">
-    <PropertyGroup>
-      <PublishAot>false</PublishAot>
-      <PublishTrimmed>false</PublishTrimmed>
-      <EnableAotAnalyzer>false</EnableAotAnalyzer>
-      <EnableTrimAnalyzer>false</EnableTrimAnalyzer>
-      <EnableSingleFileAnalyzer>false</EnableSingleFileAnalyzer>
-    </PropertyGroup>
-    <ItemGroup>
-      <ProjectCapability Remove="NativeAOT;PublishAot;PublishTrimmed" />
-    </ItemGroup>
-  </Target>
-
-  <!-- If the AppHost is a file-based app, add an implicit reference to the Aspire.Hosting.AppHost package if not already referenced.
-       This is done here so that file-based apps only need to set the single #sdk: directive line to make them an Aspire AppHost.
+  <!-- Add an implicit reference to the Aspire.Hosting.AppHost package if not already referenced.
+       This is done here so that AppHost projects and file-based apps only need to set the SDK to make them an Aspire AppHost.
        This mechanism can be disabled by setting `SkipAddAspireDefaultReferences` to `true` -->
-  <Target Name="AddImplicitAspireAppHostPackage" BeforeTargets="Restore;CollectPackageReferences" Condition="'$(_ForceAspireFileBasedAppHostDefaults)' == 'true' and '$(SkipAddAspireDefaultReferences)' != 'true'">
+  <Target Name="AddImplicitAspireAppHostPackage" BeforeTargets="Restore;CollectPackageReferences" Condition="'$(SkipAddAspireDefaultReferences)' != 'true'">
     <PropertyGroup>
       <_ImplicitAppHostVersion>@VERSION@</_ImplicitAppHostVersion>
     </PropertyGroup>

src/Aspire.Dashboard/Model/ResourceIconHelpers.cs

@@ -51,7 +51,7 @@ string t when t.Contains("database", StringComparison.OrdinalIgnoreCase) => icon
                 var extension = Path.GetExtension(projectPath);
                 return extension?.ToLowerInvariant() switch
                 {
-                    ".csproj" => iconResolver.ResolveIconName("CodeCsRectangle", desiredSize, desiredVariant),
+                    ".csproj" or ".cs" => iconResolver.ResolveIconName("CodeCsRectangle", desiredSize, desiredVariant),
                     ".fsproj" => iconResolver.ResolveIconName("CodeFsRectangle", desiredSize, desiredVariant),
                     ".vbproj" => iconResolver.ResolveIconName("CodeVbRectangle", desiredSize, desiredVariant),
                     _ => iconResolver.ResolveIconName("CodeCircle", desiredSize, desiredVariant)

src/Aspire.Hosting.AppHost/build/Aspire.Hosting.AppHost.in.targets

@@ -60,6 +60,15 @@ namespace Projects%3B
     /// The path to the ]]>%(ClassName)<![CDATA[ project.
     /// </summary>
     public string ProjectPath => """]]>%(ProjectPath)<![CDATA["""%3B
+
+    /// <summary>
+    /// Gets a value indicating whether building the project before running it should be suppressed.
+    /// </summary>
+    /// <remarks>
+    /// Projects added via ProjectReference items in the AppHost project file are built as part of building the AppHost projectprocess
+    /// so building them again before running is unnecessary. This property always returns true.
+    /// </remarks>
+    public bool SuppressBuild => true%3B
 }]]>
         </Source>
       </AspireProjectMetadataSource>
@@ -96,7 +105,7 @@ namespace Projects%3B
 
 #pragma warning disable CS8981 // The type name only contains lower-cased ascii characters. Such names may become reserved for the language.
 /// <summary>
-/// Metadata for the Aspire Host project.
+/// Metadata for the Aspire AppHost project.
 /// </summary>
 [global::System.CodeDom.Compiler.GeneratedCode("Aspire.Hosting", null)]
 [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage(Justification = "Generated code.")]

src/Aspire.Hosting/ApplicationModel/ProjectResource.cs

@@ -39,3 +39,13 @@ internal bool ShouldInjectEndpointEnvironment(EndpointReference e)
             .Any(f => !f(endpoint));
     }
 }
+
+/// <summary>
+/// A resource that represents a specified C# project or file-based app.
+/// </summary>
+/// <param name="name">The name of the resource.</param>
+public class CSharpAppResource(string name)
+    : ProjectResource(name)
+{
+
+}

src/Aspire.Hosting/Dcp/DcpExecutor.cs

@@ -1044,14 +1044,18 @@ private void PrepareProjectExecutables()
                 {
                     exeSpec.Spec.ExecutionType = ExecutionType.Process;
 
+                    // `dotnet watch` does not work with file-based apps yet, so we have to use `dotnet run` in that case
                     if (_configuration.GetBool("DOTNET_WATCH") is not true || projectMetadata.IsFileBasedApp)
                     {
                         projectArgs.AddRange([
                             "run",
-                            "--no-build",
                             projectMetadata.IsFileBasedApp ? "--file" : "--project",
                             projectMetadata.ProjectPath,
                         ]);
+                        if (projectMetadata.SuppressBuild)
+                        {
+                            projectArgs.Add("--no-build");
+                        }
                     }
                     else
                     {
@@ -1066,7 +1070,7 @@ private void PrepareProjectExecutables()
 
                     if (!string.IsNullOrEmpty(_distributedApplicationOptions.Configuration))
                     {
-                        projectArgs.AddRange(new[] { "-c", _distributedApplicationOptions.Configuration });
+                        projectArgs.AddRange(new[] { "--configuration", _distributedApplicationOptions.Configuration });
                     }
 
                     // We pretty much always want to suppress the normal launch profile handling

src/Aspire.Hosting/IProjectMetadata.cs

@@ -25,6 +25,11 @@ public interface IProjectMetadata : IResourceAnnotation
     // Internal for testing.
     internal IConfiguration? Configuration => null;
 
+    /// <summary>
+    /// Gets a value indicating whether building the project before running it should be suppressed.
+    /// </summary>
+    public bool SuppressBuild => false;
+
     internal bool IsFileBasedApp => string.Equals(Path.GetExtension(ProjectPath), ".cs", StringComparison.OrdinalIgnoreCase);
 }
 
@@ -33,6 +38,8 @@ internal sealed class ProjectMetadata(string projectPath) : IProjectMetadata
 {
     public string ProjectPath { get; } = ResolveProjectPath(projectPath);
 
+    public bool SuppressBuild => false;
+
     private static string ResolveProjectPath(string path)
     {
         if (Directory.Exists(path))

src/Aspire.Hosting/ProjectResourceBuilderExtensions.cs

@@ -289,12 +289,29 @@ public static IResourceBuilder<ProjectResource> AddProject(this IDistributedAppl
     }
 
     /// <summary>
-    /// 
+    /// Adds a C# project or file-based app to the application model.
     /// </summary>
-    /// <param name="builder"></param>
-    /// <param name="name"></param>
-    /// <param name="path"></param>
-    /// <returns></returns>
+    /// <param name="builder">The <see cref="IDistributedApplicationBuilder"/>.</param>
+    /// <param name="name">The name of the resource. This name will be used for service discovery when referenced in a dependency.</param>
+    /// <param name="path">The path to the file-based app file, project file, or project directory.</param>
+    /// <returns>A reference to the <see cref="IResourceBuilder{T}"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// This overload of the <see cref="AddCSharpApp(IDistributedApplicationBuilder, string, string)"/> method adds a C# project or file-based app to the application
+    /// model using a path to the file-based app .cs file, project file (.csproj), or project directory.
+    /// If the path is not an absolute path then it will be computed relative to the app host directory.
+    /// </para>
+    /// <example>
+    /// Add a file-based app to the app model via a file path.
+    /// <code lang="csharp">
+    /// var builder = DistributedApplication.CreateBuilder(args);
+    ///
+    /// builder.AddCSharpApp("inventoryservice", @"..\InventoryService.cs");
+    ///
+    /// builder.Build().Run();
+    /// </code>
+    /// </example>
+    /// </remarks>
     [Experimental("ASPIRECSHARPAPPS001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
     public static IResourceBuilder<ProjectResource> AddCSharpApp(this IDistributedApplicationBuilder builder, string name, string path)
     {
@@ -306,15 +323,32 @@ public static IResourceBuilder<ProjectResource> AddCSharpApp(this IDistributedAp
     }
 
     /// <summary>
-    /// 
+    /// Adds a C# project or file-based app to the application model.
     /// </summary>
-    /// <param name="builder"></param>
-    /// <param name="name"></param>
-    /// <param name="path"></param>
-    /// <param name="configure"></param>
-    /// <returns></returns>
+    /// <param name="builder">The <see cref="IDistributedApplicationBuilder"/>.</param>
+    /// <param name="name">The name of the resource. This name will be used for service discovery when referenced in a dependency.</param>
+    /// <param name="path">The path to the file-based app file, project file, or project directory.</param>
+    /// <param name="configure">An optional action to configure the C# app resource options.</param>
+    /// <returns>A reference to the <see cref="IResourceBuilder{T}"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// This overload of the <see cref="AddCSharpApp(IDistributedApplicationBuilder, string, string)"/> method adds a C# project or file-based app to the application
+    /// model using a path to the file-based app .cs file, project file (.csproj), or project directory.
+    /// If the path is not an absolute path then it will be computed relative to the app host directory.
+    /// </para>
+    /// <example>
+    /// Add a file-based app to the app model via a file path.
+    /// <code lang="csharp">
+    /// var builder = DistributedApplication.CreateBuilder(args);
+    ///
+    /// builder.AddCSharpApp("inventoryservice", @"..\InventoryService.cs");
+    ///
+    /// builder.Build().Run();
+    /// </code>
+    /// </example>
+    /// </remarks>
     [Experimental("ASPIRECSHARPAPPS001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
-    public static IResourceBuilder<ProjectResource> AddCSharpApp(this IDistributedApplicationBuilder builder, [ResourceName] string name, string path, Action<ProjectResourceOptions> configure)
+    public static IResourceBuilder<CSharpAppResource> AddCSharpApp(this IDistributedApplicationBuilder builder, [ResourceName] string name, string path, Action<ProjectResourceOptions> configure)
     {
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentNullException.ThrowIfNull(name);
@@ -324,24 +358,25 @@ public static IResourceBuilder<ProjectResource> AddCSharpApp(this IDistributedAp
         var options = new ProjectResourceOptions();
         configure(options);
 
-        var project = new ProjectResource(name);
+        var app = new CSharpAppResource(name);
 
         path = PathNormalizer.NormalizePathForCurrentPlatform(Path.Combine(builder.AppHostDirectory, path));
         IProjectMetadata projectMetadata = new ProjectMetadata(path);
 
-        if (projectMetadata.IsFileBasedApp && (RuntimeUtils.TryGetVersion(out var version) && version.Major < 10))
+        if (projectMetadata.IsFileBasedApp && RuntimeUtils.TryGetVersion(out var version) && version.Major < 10)
         {
-            // File-based apps are only supported on .NET 10 and later
-            throw new DistributedApplicationException($"File-based apps are only supported on .NET 10 and later. The current version is {version?.ToString() ?? "unknown"}.");
+            // File-based apps are only supported on .NET 10 or later
+            throw new DistributedApplicationException($"File-based apps are only supported on .NET 10 or later. The current version is {version?.ToString() ?? "unknown"}.");
         }
 
-        return builder.AddResource(project)
+        return builder.AddResource(app)
                       .WithAnnotation(projectMetadata)
-                      .WithVSCodeDebugSupport(path, "coreclr", "ms-dotnettools.csharp")
+                      .WithVSCodeDebugSupport(mode => new ProjectLaunchConfiguration { ProjectPath = projectMetadata.ProjectPath, Mode = mode }, "ms-dotnettools.csharp")
                       .WithProjectDefaults(options);
     }
 
-    private static IResourceBuilder<ProjectResource> WithProjectDefaults(this IResourceBuilder<ProjectResource> builder, ProjectResourceOptions options)
+    private static IResourceBuilder<TProjectResource> WithProjectDefaults<TProjectResource>(this IResourceBuilder<TProjectResource> builder, ProjectResourceOptions options)
+        where TProjectResource : ProjectResource
     {
         // We only want to turn these on for .NET projects, ConfigureOtlpEnvironment works for any resource type that
         // implements IDistributedApplicationResourceWithEnvironment.