Optimize AppHost project inspection (#17246)

Centralize .NET AppHost MSBuild metadata inspection, coalesce per-process probes, and add a content-keyed disk cache so warm no-build startup can skip repeated project evaluations.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: davidfowl

src/Aspire.Cli/Caching/AppHostInfoDiskCache.cs

@@ -5,6 +5,8 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Text.Json.Nodes;
+using Aspire.Cli.Caching;
+using Aspire.Cli.Projects;
 using Aspire.Cli.Certificates;
 using Aspire.Cli.Commands;
 using Aspire.Cli.Configuration;
@@ -49,6 +51,8 @@ namespace Aspire.Cli;
 [JsonSerializable(typeof(IntegrationSearchResult[]))]
 [JsonSerializable(typeof(string[]))]
 [JsonSerializable(typeof(List<CandidateAppHostDisplayInfo>))]
+[JsonSerializable(typeof(AppHostInfoCacheEntry))]
+[JsonSerializable(typeof(AppHostProjectInspectionOutput))]
 internal partial class JsonSourceGenerationContext : JsonSerializerContext
 {
     private static JsonSourceGenerationContext? s_relaxedEscaping;

src/Aspire.Cli/JsonSourceGenerationContext.cs

@@ -385,6 +385,8 @@ internal static async Task<IHost> BuildApplicationAsync(string[] args, CliStartu
 
         builder.Services.AddTransient<IDotNetCliRunner, DotNetCliRunner>();
         builder.Services.AddSingleton<IDiskCache, DiskCache>();
+        builder.Services.AddSingleton<IAppHostInfoDiskCache, AppHostInfoDiskCache>();
+        builder.Services.AddSingleton<IAppHostInfoResolver, AppHostInfoResolver>();
         builder.Services.AddSingleton<IDotNetSdkInstaller, DotNetSdkInstaller>();
         builder.Services.AddTransient<IAppHostCliBackchannel, AppHostCliBackchannel>();
 

src/Aspire.Cli/Program.cs

@@ -0,0 +1,271 @@
+// 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.Concurrent;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Aspire.Cli.Caching;
+using Aspire.Cli.DotNet;
+
+namespace Aspire.Cli.Projects;
+
+internal interface IAppHostInfoResolver
+{
+    Task<AppHostProjectInfo> GetAppHostInfoAsync(FileInfo projectFile, CancellationToken cancellationToken);
+}
+
+internal sealed class AppHostInfoResolver(IDotNetCliRunner runner, IAppHostInfoDiskCache diskCache) : IAppHostInfoResolver
+{
+    private readonly ConcurrentDictionary<(string Path, DateTime LastWriteUtc), Task<AppHostProjectInfo>> _cache = new();
+
+    public async Task<AppHostProjectInfo> GetAppHostInfoAsync(FileInfo projectFile, CancellationToken cancellationToken)
+    {
+        // Refresh so FileInfo reflects the on-disk mtime even when callers pass a long-lived instance.
+        projectFile.Refresh();
+        var key = (projectFile.FullName, projectFile.LastWriteTimeUtc);
+        var task = GetOrAddSharedFetch(key, projectFile);
+
+        try
+        {
+            // The MSBuild probe is shared by all callers for this project snapshot, so it cannot
+            // use any one caller's token. Apply cancellation to each waiter instead; otherwise one
+            // cancelled validation could cancel the shared probe for unrelated callers.
+            var result = await task.WaitAsync(cancellationToken).ConfigureAwait(false);
+            if (result.ExitCode != 0)
+            {
+                // Transient MSBuild failures should not poison long-lived CLI processes.
+                _cache.TryRemove(key, out _);
+            }
+
+            return result;
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested && !task.IsCompleted)
+        {
+            throw;
+        }
+        catch
+        {
+            // A cancelled or faulted in-flight probe must not become the answer for later runs.
+            _cache.TryRemove(key, out _);
+            throw;
+        }
+    }
+
+    private Task<AppHostProjectInfo> GetOrAddSharedFetch((string Path, DateTime LastWriteUtc) key, FileInfo projectFile)
+    {
+        while (true)
+        {
+            if (_cache.TryGetValue(key, out var existingTask))
+            {
+                return existingTask;
+            }
+
+            // ConcurrentDictionary.GetOrAdd can run value factories more than once under contention.
+            // Add a TaskCompletionSource placeholder first, then run the MSBuild probe only if this
+            // caller won the TryAdd race. Losers loop back and await the winner's task.
+            var completion = new TaskCompletionSource<AppHostProjectInfo>(TaskCreationOptions.RunContinuationsAsynchronously);
+            if (_cache.TryAdd(key, completion.Task))
+            {
+                _ = CompleteSharedFetchAsync(key, projectFile, completion);
+                return completion.Task;
+            }
+        }
+    }
+
+    private async Task CompleteSharedFetchAsync((string Path, DateTime LastWriteUtc) key, FileInfo projectFile, TaskCompletionSource<AppHostProjectInfo> completion)
+    {
+        try
+        {
+            var result = await FetchAppHostInfoCoreAsync(projectFile, CancellationToken.None).ConfigureAwait(false);
+            completion.TrySetResult(result);
+        }
+        catch (Exception ex)
+        {
+            // Match the retry behavior in GetAppHostInfoAsync: transient MSBuild/cache failures
+            // should complete all current waiters, then allow the next caller to try again.
+            completion.TrySetException(ex);
+            _cache.TryRemove(key, out _);
+        }
+    }
+
+    private async Task<AppHostProjectInfo> FetchAppHostInfoCoreAsync(FileInfo projectFile, CancellationToken cancellationToken)
+    {
+        // First, see if a previous CLI invocation already cached the answer on disk. The
+        // cache key includes mtimes of the tracked inputs that affect this metadata query, so a
+        // hit means those inputs have not changed since that previous evaluation. This is not a
+        // build-output cache; normal build/no-build semantics still decide whether .cs changes are
+        // compiled before the AppHost runs.
+        var diskEntry = await diskCache.TryGetAsync(projectFile, cancellationToken).ConfigureAwait(false);
+        if (diskEntry is not null)
+        {
+            return new AppHostProjectInfo(
+                ExitCode: diskEntry.ExitCode,
+                IsAspireHost: diskEntry.IsAspireHost,
+                AspireHostingVersion: diskEntry.AspireHostingVersion,
+                IsUsingCliBundle: diskEntry.IsUsingCliBundle,
+                UserSecretsId: diskEntry.UserSecretsId);
+        }
+
+        // Capture the input fingerprint before evaluating MSBuild. If any tracked input changes
+        // while MSBuild is running, SetAsync will skip writing this now-stale result.
+        var expectedCacheKey = diskCache.GetCacheKey(projectFile);
+
+        // Mirror the property/item shape used by DotNetCliRunner.GetAppHostInformationAsync and
+        // additionally request AspireUseCliBundle and UserSecretsId so the CLI bundle handoff
+        // and --isolated user-secrets clone do not require their own MSBuild evaluations.
+        // Adding extra -getProperty names is an evaluation-only cost.
+        var (exitCode, jsonDocument) = await runner.GetProjectItemsAndPropertiesAsync(
+            projectFile,
+            items: ["PackageReference", "AspireProjectOrPackageReference", "PackageVersion"],
+            properties: ["IsAspireHost", "AspireHostingSDKVersion", "AspireUseCliBundle", "UserSecretsId"],
+            new ProcessInvocationOptions(),
+            cancellationToken).ConfigureAwait(false);
+
+        if (exitCode != 0 || jsonDocument is null)
+        {
+            // Do not persist failure responses to memory or disk — a transient MSBuild error should
+            // not sit in a cache and short-circuit later successful evaluations.
+            // DotNetCliRunner already logged the failing MSBuild stdout/stderr before returning
+            // null here; keep the non-zero exit code so callers can surface the normal
+            // "not buildable AppHost" project-resolution behavior instead of treating this as a
+            // negative cache entry.
+            return new AppHostProjectInfo(ExitCode: exitCode, IsAspireHost: false, AspireHostingVersion: null, IsUsingCliBundle: false, UserSecretsId: null);
+        }
+
+        AppHostProjectInfo info;
+        using (jsonDocument)
+        {
+            var msbuildOutput = JsonSerializer.Deserialize(
+                jsonDocument.RootElement,
+                JsonSourceGenerationContext.Default.AppHostProjectInspectionOutput);
+
+            info = ParseAppHostInfo(msbuildOutput, exitCode);
+        }
+
+        // Persist successful evaluations so the next CLI process can short-circuit MSBuild
+        // entirely when the inputs are unchanged. Failures inside the cache write are
+        // swallowed; cache misses never break a run.
+        await diskCache.SetAsync(projectFile, expectedCacheKey, new AppHostInfoCacheEntry
+        {
+            ExitCode = info.ExitCode,
+            IsAspireHost = info.IsAspireHost,
+            AspireHostingVersion = info.AspireHostingVersion,
+            IsUsingCliBundle = info.IsUsingCliBundle,
+            UserSecretsId = info.UserSecretsId,
+        }, cancellationToken).ConfigureAwait(false);
+
+        return info;
+    }
+
+    private static AppHostProjectInfo ParseAppHostInfo(AppHostProjectInspectionOutput? msbuildOutput, int exitCode)
+    {
+        var properties = msbuildOutput?.Properties;
+        if (properties is null)
+        {
+            return new AppHostProjectInfo(ExitCode: exitCode, IsAspireHost: false, AspireHostingVersion: null, IsUsingCliBundle: false, UserSecretsId: null);
+        }
+
+        var isUsingCliBundle = string.Equals(properties.AspireUseCliBundle, "true", StringComparison.OrdinalIgnoreCase);
+
+        var userSecretsId = string.IsNullOrWhiteSpace(properties.UserSecretsId) ? null : properties.UserSecretsId;
+
+        var isAspireHost = string.Equals(properties.IsAspireHost, "true", StringComparison.Ordinal);
+
+        if (!isAspireHost)
+        {
+            return new AppHostProjectInfo(ExitCode: exitCode, IsAspireHost: false, AspireHostingVersion: null, IsUsingCliBundle: isUsingCliBundle, UserSecretsId: userSecretsId);
+        }
+
+        // Try to get Aspire.Hosting version from PackageReference items first, then fall back
+        // to AspireProjectOrPackageReference (for SDK-provided refs) and PackageVersion (CPM),
+        // then finally to the SDK version. Mirrors DotNetCliRunner.GetAppHostInformationAsync.
+        string? aspireHostingVersion = null;
+
+        var items = msbuildOutput?.Items;
+        if (items is not null)
+        {
+            aspireHostingVersion = GetPackageVersionFromItems(items.PackageReference, "Aspire.Hosting")
+                ?? GetPackageVersionFromItems(items.PackageReference, "Aspire.Hosting.AppHost");
+
+            aspireHostingVersion ??= GetPackageVersionFromItems(items.AspireProjectOrPackageReference, "Aspire.Hosting")
+                ?? GetPackageVersionFromItems(items.AspireProjectOrPackageReference, "Aspire.Hosting.AppHost");
+
+            aspireHostingVersion ??= GetPackageVersionFromItems(items.PackageVersion, "Aspire.Hosting")
+                ?? GetPackageVersionFromItems(items.PackageVersion, "Aspire.Hosting.AppHost");
+        }
+
+        aspireHostingVersion ??= properties.AspireHostingSDKVersion;
+
+        return new AppHostProjectInfo(ExitCode: exitCode, IsAspireHost: true, AspireHostingVersion: aspireHostingVersion, IsUsingCliBundle: isUsingCliBundle, UserSecretsId: userSecretsId);
+    }
+
+    private static string? GetPackageVersionFromItems(IReadOnlyList<AppHostProjectInspectionItem>? items, string packageId)
+    {
+        if (items is null)
+        {
+            return null;
+        }
+
+        foreach (var item in items)
+        {
+            if (string.Equals(item.Identity, packageId, StringComparison.Ordinal))
+            {
+                return item.Version;
+            }
+        }
+
+        return null;
+    }
+}
+
+internal sealed record AppHostProjectInfo(
+    int ExitCode,
+    bool IsAspireHost,
+    string? AspireHostingVersion,
+    bool IsUsingCliBundle,
+    string? UserSecretsId);
+
+internal sealed record AppHostProjectInspectionOutput
+{
+    [JsonPropertyName("Properties")]
+    public AppHostProjectInspectionProperties? Properties { get; init; }
+
+    [JsonPropertyName("Items")]
+    public AppHostProjectInspectionItems? Items { get; init; }
+}
+
+internal sealed record AppHostProjectInspectionProperties
+{
+    [JsonPropertyName("IsAspireHost")]
+    public string? IsAspireHost { get; init; }
+
+    [JsonPropertyName("AspireHostingSDKVersion")]
+    public string? AspireHostingSDKVersion { get; init; }
+
+    [JsonPropertyName("AspireUseCliBundle")]
+    public string? AspireUseCliBundle { get; init; }
+
+    [JsonPropertyName("UserSecretsId")]
+    public string? UserSecretsId { get; init; }
+}
+
+internal sealed record AppHostProjectInspectionItems
+{
+    [JsonPropertyName("PackageReference")]
+    public IReadOnlyList<AppHostProjectInspectionItem>? PackageReference { get; init; }
+
+    [JsonPropertyName("AspireProjectOrPackageReference")]
+    public IReadOnlyList<AppHostProjectInspectionItem>? AspireProjectOrPackageReference { get; init; }
+
+    [JsonPropertyName("PackageVersion")]
+    public IReadOnlyList<AppHostProjectInspectionItem>? PackageVersion { get; init; }
+}
+
+internal sealed record AppHostProjectInspectionItem
+{
+    [JsonPropertyName("Identity")]
+    public string? Identity { get; init; }
+
+    [JsonPropertyName("Version")]
+    public string? Version { get; init; }
+}