Reduce NamedPipe Chatter (take 2)

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorConfiguration.cs

@@ -1,8 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
+using Microsoft.AspNetCore.Razor.Utilities;
 using Microsoft.Extensions.Internal;
 
 namespace Microsoft.AspNetCore.Razor.Language;
@@ -21,6 +25,10 @@ public sealed record class RazorConfiguration(
         LanguageServerFlags: null,
         UseConsolidatedMvcViews: true);
 
+    private Checksum? _checksum;
+    internal Checksum Checksum
+        => _checksum ?? InterlockedOperations.Initialize(ref _checksum, CalculateChecksum());
+
     public bool Equals(RazorConfiguration? other)
         => other is not null &&
            LanguageVersion == other.LanguageVersion &&
@@ -39,4 +47,24 @@ public override int GetHashCode()
         hash.Add(LanguageServerFlags);
         return hash;
     }
+
+    internal void CalculateChecksum(Checksum.Builder builder)
+    {
+        builder.AppendData(LanguageVersion.Major);
+        builder.AppendData(LanguageVersion.Minor);
+        builder.AppendData(ConfigurationName);
+        builder.AppendData(UseConsolidatedMvcViews);
+
+        foreach (var extension in Extensions)
+        {
+            builder.AppendData(extension.ExtensionName);
+        }
+    }
+
+    private Checksum CalculateChecksum()
+    {
+        var builder = new Checksum.Builder();
+        CalculateChecksum(builder);
+        return builder.FreeAndGetChecksum();
+    }
 }

src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace/RazorWorkspaceListenerBase.ProjectEntry.cs

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.Razor.Utilities;
+
+namespace Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace;
+
+public abstract partial class RazorWorkspaceListenerBase
+{
+    internal class ProjectEntry
+    {
+        public int? TagHelpersResultId { get; set; }
+        public Checksum? ProjectChecksum { get; set; }
+    }
+}

src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace/RazorWorkspaceListenerBase.Work.cs

@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace;
+
+public abstract partial class RazorWorkspaceListenerBase
+{
+    internal record Work(ProjectId ProjectId);
+    internal record UpdateWork(ProjectId ProjectId) : Work(ProjectId);
+    internal record RemovalWork(ProjectId ProjectId, string IntermediateOutputPath) : Work(ProjectId);
+}

src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace/RazorWorkspaceListenerBase.cs

@@ -3,19 +3,24 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.AspNetCore.Razor.Serialization;
+using Microsoft.AspNetCore.Razor.Telemetry;
 using Microsoft.AspNetCore.Razor.Utilities;
 using Microsoft.CodeAnalysis;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace;
 
-public abstract class RazorWorkspaceListenerBase : IDisposable
+public abstract partial class RazorWorkspaceListenerBase : IDisposable
 {
     private static readonly TimeSpan s_debounceTime = TimeSpan.FromMilliseconds(500);
     private readonly CancellationTokenSource _disposeTokenSource = new();
 
     private readonly ILogger _logger;
     private readonly AsyncBatchingWorkQueue<Work> _workQueue;
+    private readonly CachedTagHelperResolver _cachedTagHelperResolver = new(NoOpTelemetryReporter.Instance);
+    private readonly Dictionary<ProjectId, ImmutableArray<DocumentSnapshotHandle>> _documentSnapshots = new();
+    private readonly Dictionary<ProjectId, ProjectEntry> _projectEntryMap = new();
 
     // Use an immutable dictionary for ImmutableInterlocked operations. The value isn't checked, just
     // the existance of the key so work is only done for projects with dynamic files.
@@ -25,10 +30,6 @@ public abstract class RazorWorkspaceListenerBase : IDisposable
     private Workspace? _workspace;
     private bool _disposed;
 
-    internal record Work(ProjectId ProjectId);
-    internal record UpdateWork(ProjectId ProjectId) : Work(ProjectId);
-    internal record RemovalWork(ProjectId ProjectId, string IntermediateOutputPath) : Work(ProjectId);
-
     private protected RazorWorkspaceListenerBase(ILogger logger)
     {
         _logger = logger;
@@ -195,7 +196,7 @@ void RemoveProject(Project project)
         {
             // Remove project is called from Workspace.Changed, while other notifications of _projectsWithDynamicFile
             // are handled with NotifyDynamicFile. Use ImmutableInterlocked here to be sure the updates happen
-            // in a thread safe manner since those are not assumed to be the same thread. 
+            // in a thread safe manner since those are not assumed to be the same thread.
             if (ImmutableInterlocked.TryRemove(ref _projectsWithDynamicFile, project.Id, out var _))
             {
                 var intermediateOutputPath = Path.GetDirectoryName(project.CompilationOutputInfo.AssemblyPath);
@@ -227,18 +228,18 @@ private protected async virtual ValueTask ProcessWorkAsync(ImmutableArray<Work>
 
         cancellationToken.ThrowIfCancellationRequested();
 
-        // Early bail check for if we are disposed or somewhere in the middle of disposal 
+        // Early bail check for if we are disposed or somewhere in the middle of disposal
         if (_disposed || stream is null || solution is null)
         {
             _logger.LogTrace("Skipping work due to disposal");
             return;
         }
 
         await CheckConnectionAsync(stream, cancellationToken).ConfigureAwait(false);
-        await ProcessWorkCoreAsync(work, stream, solution, _logger, cancellationToken).ConfigureAwait(false);
+        await ProcessWorkCoreAsync(work, stream, solution, cancellationToken).ConfigureAwait(false);
     }
 
-    private static async Task ProcessWorkCoreAsync(ImmutableArray<Work> work, Stream stream, Solution solution, ILogger logger, CancellationToken cancellationToken)
+    private async Task ProcessWorkCoreAsync(ImmutableArray<Work> work, Stream stream, Solution solution, CancellationToken cancellationToken)
     {
         foreach (var unit in work)
         {
@@ -248,21 +249,21 @@ private static async Task ProcessWorkCoreAsync(ImmutableArray<Work> work, Stream
 
                 if (unit is RemovalWork removalWork)
                 {
-                    await ReportRemovalAsync(stream, removalWork, logger, cancellationToken).ConfigureAwait(false);
+                    await ReportRemovalAsync(stream, removalWork, _logger, cancellationToken).ConfigureAwait(false);
                 }
 
                 var project = solution.GetProject(unit.ProjectId);
                 if (project is null)
                 {
-                    logger.LogTrace("Project {projectId} is not in workspace", unit.ProjectId);
+                    _logger.LogTrace("Project {projectId} is not in workspace", unit.ProjectId);
                     continue;
                 }
 
-                await ReportUpdateProjectAsync(stream, project, logger, cancellationToken).ConfigureAwait(false);
+                await ReportUpdateProjectAsync(stream, project, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex) when (ex is not OperationCanceledException)
             {
-                logger.LogError(ex, "Encountered exception while processing unit: {message}", ex.Message);
+                _logger.LogError(ex, "Encountered exception while processing unit: {message}", ex.Message);
             }
         }
 
@@ -272,22 +273,48 @@ private static async Task ProcessWorkCoreAsync(ImmutableArray<Work> work, Stream
         }
         catch (Exception ex)
         {
-            logger.LogError(ex, "Encountered error flusingh stream");
+            _logger.LogError(ex, "Encountered error flushing stream");
         }
     }
 
-    private static async Task ReportUpdateProjectAsync(Stream stream, Project project, ILogger logger, CancellationToken cancellationToken)
+    private async Task ReportUpdateProjectAsync(Stream stream, Project project, CancellationToken cancellationToken)
     {
-        logger.LogTrace("Serializing information for {projectId}", project.Id);
-        var projectInfo = await RazorProjectInfoFactory.ConvertAsync(project, logger, cancellationToken).ConfigureAwait(false);
-        if (projectInfo is null)
+        _logger.LogTrace("Serializing information for {projectId}", project.Id);
+        var projectPath = Path.GetDirectoryName(project.FilePath);
+        if (projectPath is null)
         {
-            logger.LogTrace("Skipped writing data for {projectId}", project.Id);
+            _logger.LogInformation("projectPath is null, skip update for {projectId}", project.Id);
             return;
         }
 
-        stream.WriteProjectInfoAction(ProjectInfoAction.Update);
-        await stream.WriteProjectInfoAsync(projectInfo, cancellationToken).ConfigureAwait(false);
+        var intermediateOutputPath = Path.GetDirectoryName(project.CompilationOutputInfo.AssemblyPath);
+        if (intermediateOutputPath is null)
+        {
+            _logger.LogInformation("intermediateOutputPath is null, skip update for {projectId}", project.Id);
+            return;
+        }
+
+        var entry = _projectEntryMap.GetOrAdd(project.Id, static _ => new ProjectEntry());
+
+        var delta = await _cachedTagHelperResolver.GetDeltaAsync(project, entry.TagHelpersResultId, cancellationToken).ConfigureAwait(false);
+        entry.TagHelpersResultId = delta.ResultId;
+
+        var tagHelpers = _cachedTagHelperResolver.GetValues(project.Id, delta.ResultId);
+        var projectInfo = RazorProjectInfoHelpers.TryConvert(project, projectPath, intermediateOutputPath, tagHelpers);
+        if (projectInfo is not null)
+        {
+            var checkSum = projectInfo.Checksum;
+            if (entry.ProjectChecksum == checkSum)
+            {
+                _logger.LogInformation("Checksum for {projectId} did not change. Skipped sending update", project.Id);
+                return;
+            }
+
+            entry.ProjectChecksum = checkSum;
+
+            stream.WriteProjectInfoAction(ProjectInfoAction.Update);
+            await stream.WriteProjectInfoAsync(projectInfo, cancellationToken).ConfigureAwait(false);
+        }
     }
 
     private static Task ReportRemovalAsync(Stream stream, RemovalWork unit, ILogger logger, CancellationToken cancellationToken)

src/Razor/src/Microsoft.AspNetCore.Razor.ProjectEngineHost/CachedTagHelperResolver.DeltaResult.cs

@@ -0,0 +1,47 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using Microsoft.AspNetCore.Razor.PooledObjects;
+using Microsoft.AspNetCore.Razor.Utilities;
+
+#if DEBUG
+using System.Diagnostics;
+#endif
+
+namespace Microsoft.AspNetCore.Razor;
+
+internal partial class CachedTagHelperResolver
+{
+    public sealed record class DeltaResult(
+        bool IsDelta,
+        int ResultId,
+        ImmutableArray<Checksum> Added,
+        ImmutableArray<Checksum> Removed)
+    {
+        public ImmutableArray<Checksum> Apply(ImmutableArray<Checksum> baseChecksums)
+        {
+            if (Added.Length == 0 && Removed.Length == 0)
+            {
+                return baseChecksums;
+            }
+
+            using var result = new PooledArrayBuilder<Checksum>(capacity: baseChecksums.Length + Added.Length - Removed.Length);
+
+            result.AddRange(Added);
+            result.AddRange(Delta.Compute(Removed, baseChecksums));
+
+#if DEBUG
+            // Ensure that there are no duplicate tag helpers in the result.
+            using var set = new PooledHashSet<Checksum>(capacity: result.Count);
+
+            foreach (var item in result)
+            {
+                Debug.Assert(set.Add(item), $"{nameof(DeltaResult)}.{nameof(Apply)} should not contain any duplicates!");
+            }
+#endif
+
+            return result.DrainToImmutable();
+        }
+    }
+}