Backflow from https://github.com/dotnet/dotnet / 6f4c060 build 289866

dotnet-maestro[bot] · dotnet-maestro[bot] · commit 00c5249ac4c2 · 2025-11-07T11:03:20.000Z
[[ commit created by automation ]]
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -37,6 +37,7 @@
     <PackageVersion Include="Microsoft.CodeAnalysis.VisualBasic.Workspaces" Version="$(MicrosoftCodeAnalysisPackageVersion)" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="$(MicrosoftCodeAnalysisPackageVersion)" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="$(MicrosoftCodeAnalysisWorkspacesMSBuildPackageVersion)" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.ExternalAccess.HotReload" Version="$(MicrosoftCodeAnalysisExternalAccessHotReloadPackageVersion)" />
 
     <!-- roslyn-sdk dependencies-->
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing" Version="1.1.2" />
diff --git a/eng/Publishing.props b/eng/Publishing.props
@@ -43,6 +43,10 @@
     <Artifact Remove="@(MsiPackages)" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(PublishingWorkloadMsiInternal)' == 'true'">
+    <Artifact Update="$(ArtifactsShippingPackagesDir)*.Msi.*.nupkg" Visibility="Internal" />
+  </ItemGroup>
+
   <Target Name="GetNonStableProductVersion">
     <!-- Retrieve the non-stable product version. -->
     <MSBuild Projects="$(RepoRoot)src\Layout\redist\redist.csproj"
diff --git a/eng/Versions.props b/eng/Versions.props
@@ -112,7 +112,7 @@
          At usage sites, either we use MicrosoftBuildMinimumVersion, or MicrosoftBuildVersion in source-only modes.
 
          Additionally, set the MinimumVSVersion for the installer UI that's required for targeting NetCurrent -->
-    <MicrosoftBuildMinimumVersion Condition="'$(DotNetBuildSourceOnly)' != 'true'">17.14.8</MicrosoftBuildMinimumVersion>
+    <MicrosoftBuildMinimumVersion Condition="'$(DotNetBuildSourceOnly)' != 'true'">17.14.28</MicrosoftBuildMinimumVersion>
     <MinimumVSVersion>18.0</MinimumVSVersion>
   </PropertyGroup>
   <PropertyGroup>
@@ -126,7 +126,7 @@
   </PropertyGroup>
   <PropertyGroup Label="Manually updated">
     <!-- Dependencies from https://github.com/microsoft/MSBuildLocator -->
-    <MicrosoftBuildLocatorPackageVersion>1.8.1</MicrosoftBuildLocatorPackageVersion>
+    <MicrosoftBuildLocatorPackageVersion>1.10.2</MicrosoftBuildLocatorPackageVersion>
     <MicrosoftCodeAnalysisCSharpAnalyzerPinnedVersionPackageVersion>4.0.1</MicrosoftCodeAnalysisCSharpAnalyzerPinnedVersionPackageVersion>
   </PropertyGroup>
   <!-- Get .NET Framework reference assemblies from NuGet packages -->
diff --git a/src/BuiltInTools/DotNetDeltaApplier/Microsoft.Extensions.DotNetDeltaApplier.csproj b/src/BuiltInTools/DotNetDeltaApplier/Microsoft.Extensions.DotNetDeltaApplier.csproj
@@ -8,6 +8,8 @@
     -->
     <TargetFrameworks>net6.0;net10.0</TargetFrameworks>
     <StrongNameKeyId>MicrosoftAspNetCore</StrongNameKeyId>
+
+    <DisableTransitiveFrameworkReferenceDownloads Condition="'$(DotNetBuildSourceOnly)' == 'true'">true</DisableTransitiveFrameworkReferenceDownloads>
   </PropertyGroup>
 
   <!-- Reference 6.0.0 targeting packs in Source Build -->
diff --git a/src/BuiltInTools/dotnet-watch/HotReload/CompilationHandler.cs b/src/BuiltInTools/dotnet-watch/HotReload/CompilationHandler.cs
@@ -6,7 +6,7 @@
 using Microsoft.Build.Graph;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.ExternalAccess.Watch.Api;
+using Microsoft.CodeAnalysis.ExternalAccess.HotReload.Api;
 using Microsoft.DotNet.HotReload;
 using Microsoft.Extensions.Logging;
 
@@ -16,7 +16,7 @@ internal sealed class CompilationHandler : IDisposable
     {
         public readonly IncrementalMSBuildWorkspace Workspace;
         private readonly ILogger _logger;
-        private readonly WatchHotReloadService _hotReloadService;
+        private readonly HotReloadService _hotReloadService;
         private readonly ProcessRunner _processRunner;
 
         /// <summary>
@@ -35,7 +35,7 @@ internal sealed class CompilationHandler : IDisposable
         /// <summary>
         /// All updates that were attempted. Includes updates whose application failed.
         /// </summary>
-        private ImmutableList<WatchHotReloadService.Update> _previousUpdates = [];
+        private ImmutableList<HotReloadService.Update> _previousUpdates = [];
 
         private bool _isDisposed;
 
@@ -44,7 +44,7 @@ public CompilationHandler(ILogger logger, ProcessRunner processRunner)
             _logger = logger;
             _processRunner = processRunner;
             Workspace = new IncrementalMSBuildWorkspace(logger);
-            _hotReloadService = new WatchHotReloadService(Workspace.CurrentSolution.Services, () => ValueTask.FromResult(GetAggregateCapabilities()));
+            _hotReloadService = new HotReloadService(Workspace.CurrentSolution.Services, () => ValueTask.FromResult(GetAggregateCapabilities()));
         }
 
         public void Dispose()
@@ -299,7 +299,7 @@ private static void PrepareCompilations(Solution solution, string projectPath, C
         }
 
         public async ValueTask<(
-                ImmutableArray<WatchHotReloadService.Update> projectUpdates,
+                ImmutableArray<HotReloadService.Update> projectUpdates,
                 ImmutableArray<string> projectsToRebuild,
                 ImmutableArray<string> projectsToRedeploy,
                 ImmutableArray<RunningProject> projectsToRestart)> HandleManagedCodeChangesAsync(
@@ -315,14 +315,14 @@ private static void PrepareCompilations(Solution solution, string projectPath, C
                 let runningProject = GetCorrespondingRunningProject(project, runningProjects)
                 where runningProject != null
                 let autoRestartProject = autoRestart || runningProject.ProjectNode.IsAutoRestartEnabled()
-                select (project.Id, info: new WatchHotReloadService.RunningProjectInfo() { RestartWhenChangesHaveNoEffect = autoRestartProject }))
+                select (project.Id, info: new HotReloadService.RunningProjectInfo() { RestartWhenChangesHaveNoEffect = autoRestartProject }))
                 .ToImmutableDictionary(e => e.Id, e => e.info);
 
             var updates = await _hotReloadService.GetUpdatesAsync(currentSolution, runningProjectInfos, cancellationToken);
 
             await DisplayResultsAsync(updates, runningProjectInfos, cancellationToken);
 
-            if (updates.Status is WatchHotReloadService.Status.NoChangesToApply or WatchHotReloadService.Status.Blocked)
+            if (updates.Status is HotReloadService.Status.NoChangesToApply or HotReloadService.Status.Blocked)
             {
                 // If Hot Reload is blocked (due to compilation error) we ignore the current
                 // changes and await the next file change.
@@ -364,7 +364,7 @@ private static void PrepareCompilations(Solution solution, string projectPath, C
             return (updates.ProjectUpdates, projectsToRebuild, projectsToRedeploy, projectsToRestart);
         }
 
-        public async ValueTask ApplyUpdatesAsync(ImmutableArray<WatchHotReloadService.Update> updates, CancellationToken cancellationToken)
+        public async ValueTask ApplyUpdatesAsync(ImmutableArray<HotReloadService.Update> updates, CancellationToken cancellationToken)
         {
             Debug.Assert(!updates.IsEmpty);
 
@@ -403,7 +403,7 @@ await ForEachProjectAsync(projectsToUpdate, async (runningProject, cancellationT
             }
 
             // msbuild workspace doesn't set TFM if the project is not multi-targeted
-            var tfm = WatchHotReloadService.GetTargetFramework(project);
+            var tfm = HotReloadService.GetTargetFramework(project);
             if (tfm == null)
             {
                 return projectsWithPath[0];
@@ -412,18 +412,18 @@ await ForEachProjectAsync(projectsToUpdate, async (runningProject, cancellationT
             return projectsWithPath.SingleOrDefault(p => string.Equals(p.ProjectNode.GetTargetFramework(), tfm, StringComparison.OrdinalIgnoreCase));
         }
 
-        private async ValueTask DisplayResultsAsync(WatchHotReloadService.Updates2 updates, ImmutableDictionary<ProjectId, WatchHotReloadService.RunningProjectInfo> runningProjectInfos, CancellationToken cancellationToken)
+        private async ValueTask DisplayResultsAsync(HotReloadService.Updates updates, ImmutableDictionary<ProjectId, HotReloadService.RunningProjectInfo> runningProjectInfos, CancellationToken cancellationToken)
         {
             switch (updates.Status)
             {
-                case WatchHotReloadService.Status.ReadyToApply:
+                case HotReloadService.Status.ReadyToApply:
                     break;
 
-                case WatchHotReloadService.Status.NoChangesToApply:
+                case HotReloadService.Status.NoChangesToApply:
                     _logger.Log(MessageDescriptor.NoCSharpChangesToApply);
                     break;
 
-                case WatchHotReloadService.Status.Blocked:
+                case HotReloadService.Status.Blocked:
                     _logger.Log(MessageDescriptor.UnableToApplyChanges);
                     break;
 
@@ -451,7 +451,7 @@ await ForEachProjectAsync(
 
             void ReportCompilationDiagnostics(DiagnosticSeverity severity)
             {
-                foreach (var diagnostic in updates.CompilationDiagnostics)
+                foreach (var diagnostic in updates.PersistentDiagnostics)
                 {
                     if (diagnostic.Id == "CS8002")
                     {
@@ -492,7 +492,7 @@ void ReportRudeEdits()
                     .Where(p => !updates.ProjectsToRestart.ContainsKey(p))
                     .ToHashSet();
 
-                foreach (var (projectId, diagnostics) in updates.RudeEdits)
+                foreach (var (projectId, diagnostics) in updates.TransientDiagnostics)
                 {
                     foreach (var diagnostic in diagnostics)
                     {
@@ -689,7 +689,7 @@ public bool TryGetRunningProject(string projectPath, out ImmutableArray<RunningP
         private static Task ForEachProjectAsync(ImmutableDictionary<string, ImmutableArray<RunningProject>> projects, Func<RunningProject, CancellationToken, Task> action, CancellationToken cancellationToken)
             => Task.WhenAll(projects.SelectMany(entry => entry.Value).Select(project => action(project, cancellationToken))).WaitAsync(cancellationToken);
 
-        private static ImmutableArray<HotReloadManagedCodeUpdate> ToManagedCodeUpdates(ImmutableArray<WatchHotReloadService.Update> updates)
+        private static ImmutableArray<HotReloadManagedCodeUpdate> ToManagedCodeUpdates(ImmutableArray<HotReloadService.Update> updates)
             => [.. updates.Select(update => new HotReloadManagedCodeUpdate(update.ModuleId, update.MetadataDelta, update.ILDelta, update.PdbDelta, update.UpdatedTypes, update.RequiredCapabilities))];
     }
 }
diff --git a/src/BuiltInTools/dotnet-watch/HotReload/IncrementalMSBuildWorkspace.cs b/src/BuiltInTools/dotnet-watch/HotReload/IncrementalMSBuildWorkspace.cs
@@ -4,7 +4,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.ExternalAccess.Watch.Api;
+using Microsoft.CodeAnalysis.ExternalAccess.HotReload.Api;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.MSBuild;
 using Microsoft.CodeAnalysis.Text;
@@ -76,7 +76,7 @@ public async Task UpdateProjectConeAsync(string rootProjectPath, CancellationTok
                 continue;
             }
 
-            newSolution = WatchHotReloadService.WithProjectInfo(newSolution, ProjectInfo.Create(
+            newSolution = HotReloadService.WithProjectInfo(newSolution, ProjectInfo.Create(
                 oldProjectId,
                 newProjectInfo.Version,
                 newProjectInfo.Name,
diff --git a/src/BuiltInTools/dotnet-watch/dotnet-watch.csproj b/src/BuiltInTools/dotnet-watch/dotnet-watch.csproj
@@ -43,6 +43,7 @@
     <PackageReference Include="Microsoft.Build.Locator" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Features" />
     <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" />
+    <PackageReference Include="Microsoft.CodeAnalysis.ExternalAccess.HotReload" />
     <PackageReference Include="Microsoft.NET.StringTools" ExcludeAssets="runtime" PrivateAssets="All" />
 
     <Compile Include="$(RepoRoot)src\Common\PathUtilities.cs" LinkBase="Common" />
diff --git a/src/RazorSdk/Tool/GenerateCommand.cs b/src/RazorSdk/Tool/GenerateCommand.cs
@@ -4,6 +4,7 @@
 #nullable disable
 
 using System.Diagnostics;
+using System.Threading;
 using Microsoft.AspNetCore.Razor.Language;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.NET.Sdk.Razor.Tool.CommandLineUtils;
@@ -433,6 +434,7 @@ private class StaticTagHelperFeature : RazorEngineFeatureBase, ITagHelperFeature
         {
             public IReadOnlyList<TagHelperDescriptor> TagHelpers { get; set; }
 
+            public IReadOnlyList<TagHelperDescriptor> GetDescriptors(CancellationToken cancellationToken) => TagHelpers;
             public IReadOnlyList<TagHelperDescriptor> GetDescriptors() => TagHelpers;
         }
     }
diff --git a/test/dotnet.Tests/CommandTests/MSBuild/GivenMSBuildLogger.cs b/test/dotnet.Tests/CommandTests/MSBuild/GivenMSBuildLogger.cs
@@ -214,5 +214,101 @@ public void ItIgnoresNonIntegerPropertiesDuringAggregation()
             fakeTelemetry.LogEntry.Properties.Should().NotContainKey("InvalidProperty");
             fakeTelemetry.LogEntry.Properties.Should().NotContainKey("InvalidProperty2");
         }
+
+        [Fact]
+        public void ItAggregatesEvents()
+        {
+            var fakeTelemetry = new FakeTelemetry();
+            fakeTelemetry.Enabled = true;
+            var logger = new MSBuildLogger(fakeTelemetry);
+
+            var event1 = new TelemetryEventArgs
+            {
+                EventName = MSBuildLogger.TaskFactoryTelemetryAggregatedEventName,
+                Properties = new Dictionary<string, string>
+                {
+                    { "AssemblyTaskFactoryTasksExecutedCount", "2" },
+                    { "RoslynCodeTaskFactoryTasksExecutedCount", "1" }
+                }
+            };
+
+            var event2 = new TelemetryEventArgs
+            {
+                EventName = MSBuildLogger.TaskFactoryTelemetryAggregatedEventName,
+                Properties = new Dictionary<string, string>
+                {
+                    { "AssemblyTaskFactoryTasksExecutedCount", "3" },
+                    { "CustomTaskFactoryTasksExecutedCount", "2" }
+                }
+            };
+
+            var event3 = new TelemetryEventArgs
+            {
+                EventName = MSBuildLogger.TasksTelemetryAggregatedEventName,
+                Properties = new Dictionary<string, string>
+                {
+                    { "TasksExecutedCount", "3" },
+                    { "TaskHostTasksExecutedCount", "2" }
+                }
+            };
+
+            var event4 = new TelemetryEventArgs
+            {
+                EventName = MSBuildLogger.TasksTelemetryAggregatedEventName,
+                Properties = new Dictionary<string, string>
+                {
+                    { "TasksExecutedCount", "5" }
+                }
+            };
+
+            logger.AggregateEvent(event1);
+            logger.AggregateEvent(event2);
+            logger.AggregateEvent(event3);
+            logger.AggregateEvent(event4);
+
+            logger.SendAggregatedEventsOnBuildFinished(fakeTelemetry);
+
+            fakeTelemetry.LogEntries.Should().HaveCount(2);
+
+            var taskFactoryEntry = fakeTelemetry.LogEntries.FirstOrDefault(e => e.EventName == $"msbuild/{MSBuildLogger.TaskFactoryTelemetryAggregatedEventName}");
+            taskFactoryEntry.Should().NotBeNull();
+            taskFactoryEntry.Properties["AssemblyTaskFactoryTasksExecutedCount"].Should().Be("5"); // 2 + 3
+            taskFactoryEntry.Properties["RoslynCodeTaskFactoryTasksExecutedCount"].Should().Be("1"); // 1 + 0
+            taskFactoryEntry.Properties["CustomTaskFactoryTasksExecutedCount"].Should().Be("2"); // 0 + 2
+
+            var tasksEntry = fakeTelemetry.LogEntries.FirstOrDefault(e => e.EventName == $"msbuild/{MSBuildLogger.TasksTelemetryAggregatedEventName}");
+            tasksEntry.Should().NotBeNull();
+            tasksEntry.Properties["TasksExecutedCount"].Should().Be("8"); // 3 + 5
+            tasksEntry.Properties["TaskHostTasksExecutedCount"].Should().Be("2"); // 2 + 0
+        }
+
+        [Fact]
+        public void ItIgnoresNonIntegerPropertiesDuringAggregation()
+        {
+            var fakeTelemetry = new FakeTelemetry();
+            fakeTelemetry.Enabled = true;
+            var logger = new MSBuildLogger(fakeTelemetry);
+            
+            var eventArgs = new TelemetryEventArgs
+            {
+                EventName = MSBuildLogger.TaskFactoryTelemetryAggregatedEventName,
+                Properties = new Dictionary<string, string>
+                {
+                    { "AssemblyTaskFactoryTasksExecutedCount", "3" },
+                    { "InvalidProperty", "not-a-number" },
+                    { "InvalidProperty2", "1.234" },
+                }
+            };
+
+            logger.AggregateEvent(eventArgs);
+
+            logger.SendAggregatedEventsOnBuildFinished(fakeTelemetry);
+
+            fakeTelemetry.LogEntry.Should().NotBeNull();
+            fakeTelemetry.LogEntry.EventName.Should().Be($"msbuild/{MSBuildLogger.TaskFactoryTelemetryAggregatedEventName}");
+            fakeTelemetry.LogEntry.Properties["AssemblyTaskFactoryTasksExecutedCount"].Should().Be("3");
+            fakeTelemetry.LogEntry.Properties.Should().NotContainKey("InvalidProperty");
+            fakeTelemetry.LogEntry.Properties.Should().NotContainKey("InvalidProperty2");
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`#nullable disable`
`5`	`5`
`6`	`6`	`using System.Diagnostics;`
	`7`	`+using System.Threading;`
`7`	`8`	`using Microsoft.AspNetCore.Razor.Language;`
`8`	`9`	`using Microsoft.CodeAnalysis.CSharp;`
`9`	`10`	`using Microsoft.NET.Sdk.Razor.Tool.CommandLineUtils;`
`@@ -433,6 +434,7 @@ private class StaticTagHelperFeature : RazorEngineFeatureBase, ITagHelperFeature`
`433`	`434`	`{`
`434`	`435`	`public IReadOnlyList<TagHelperDescriptor> TagHelpers { get; set; }`
`435`	`436`
	`437`	`+ public IReadOnlyList<TagHelperDescriptor> GetDescriptors(CancellationToken cancellationToken) => TagHelpers;`
`436`	`438`	`public IReadOnlyList<TagHelperDescriptor> GetDescriptors() => TagHelpers;`
`437`	`439`	`}`
`438`	`440`	`}`