dependabot-nuget 0.296.0 → 0.296.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22109eb4de3c3d7317682ad493e6162a7af4328e07751a27c8dbb48978597ef3
-  data.tar.gz: 9a8afdc613b3313c7e08ac3967c4abd311a6eb66a662022677bed40229e52d3b
+  metadata.gz: e95198bddff97b4ff66198a8f1bbdfd30e1277f38d13ff043c3ea11a4b03004d
+  data.tar.gz: 85d9c549fe2b678720e036d90448b0d6b4a23fef3f494ce266cfc25c837f87de
 SHA512:
-  metadata.gz: fe8805919ec14b5bf6385d4bb4ff3a1dc00137fc08c1e002d8c3db0600c4e5c2e8e86319d3e40fe4c608d29229834c3c741fa8a262b3e8d9f9c8e21755cf9029
-  data.tar.gz: d0b247df044695e253e08ed9cabbdea0341ff9234ca601c61fc48d2f13ac138ffce51683ebf45ed37478190750a791bacbc3308ab0a69e3cff70e61cffb8576a
+  metadata.gz: f6804dc6b7080b98cf7b9b1b015fcb1a2d2ea3c6e552479bdd0e198765716d6d449d0f012297931bff515b104e81f9daec49ef71f232b906799f403f110f0366
+  data.tar.gz: 73242eed344d61d77a40b8f9f65374fb0101d8efc2a805c9e80c853a5164d870776aad2828e5775baac792634053fe0897bb790ff67d2d927cc960feb716515d

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/AnalyzeWorker.cs

@@ -236,6 +236,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
         CancellationToken cancellationToken)
     {
         var versionResult = await VersionFinder.GetVersionsAsync(
+            projectFrameworks,
             dependencyInfo,
             nugetContext,
             logger,
@@ -262,6 +263,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
         CancellationToken cancellationToken)
     {
         var versionResult = await VersionFinder.GetVersionsAsync(
+            projectFrameworks,
             packageIds.First(),
             version,
             nugetContext,

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/CompatabilityChecker.cs

@@ -108,19 +108,18 @@ internal static class CompatibilityChecker
 
         foreach (var d in dependencyGroups)
         {
-            var libItems = (await readers.ContentReader.GetLibItemsAsync(cancellationToken)).ToList();
-
-            foreach (var item in libItems)
-            {
-                tfms.Add(item.TargetFramework);
-            }
-
             if (!d.TargetFramework.IsAny)
             {
                 tfms.Add(d.TargetFramework);
             }
         }
 
+        var refItems = await readers.ContentReader.GetReferenceItemsAsync(cancellationToken);
+        foreach (var refItem in refItems)
+        {
+            tfms.Add(refItem.TargetFramework);
+        }
+
         if (!tfms.Any())
         {
             tfms.Add(NuGetFramework.AnyFramework);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/VersionFinder.cs

@@ -2,6 +2,7 @@ using System.Collections.Immutable;
 
 using NuGet.Common;
 using NuGet.Configuration;
+using NuGet.Frameworks;
 using NuGet.Packaging.Core;
 using NuGet.Protocol;
 using NuGet.Protocol.Core.Types;
@@ -12,6 +13,7 @@ namespace NuGetUpdater.Core.Analyze;
 internal static class VersionFinder
 {
     public static Task<VersionResult> GetVersionsAsync(
+        ImmutableArray<NuGetFramework> projectTfms,
         string packageId,
         NuGetVersion currentVersion,
         NuGetContext nugetContext,
@@ -20,10 +22,11 @@ internal static class VersionFinder
     {
         var versionFilter = CreateVersionFilter(currentVersion);
 
-        return GetVersionsAsync(packageId, currentVersion, versionFilter, nugetContext, logger, cancellationToken);
+        return GetVersionsAsync(projectTfms, packageId, currentVersion, versionFilter, nugetContext, logger, cancellationToken);
     }
 
     public static Task<VersionResult> GetVersionsAsync(
+        ImmutableArray<NuGetFramework> projectTfms,
         DependencyInfo dependencyInfo,
         NuGetContext nugetContext,
         ILogger logger,
@@ -34,10 +37,11 @@ internal static class VersionFinder
         var currentVersion = versionRange.MinVersion!;
         var versionFilter = CreateVersionFilter(dependencyInfo, versionRange);
 
-        return GetVersionsAsync(packageId, currentVersion, versionFilter, nugetContext, logger, cancellationToken);
+        return GetVersionsAsync(projectTfms, packageId, currentVersion, versionFilter, nugetContext, logger, cancellationToken);
     }
 
     public static async Task<VersionResult> GetVersionsAsync(
+        ImmutableArray<NuGetFramework> projectTfms,
         string packageId,
         NuGetVersion currentVersion,
         Func<NuGetVersion, bool> versionFilter,
@@ -62,7 +66,14 @@ internal static class VersionFinder
             var feed = await sourceRepository.GetResourceAsync<MetadataResource>();
             if (feed is null)
             {
-                logger.Warn($"Failed to get MetadataResource for [{source.Source}]");
+                logger.Warn($"Failed to get {nameof(MetadataResource)} for [{source.Source}]");
+                continue;
+            }
+
+            var packageFinder = await sourceRepository.GetResourceAsync<FindPackageByIdResource>();
+            if (packageFinder is null)
+            {
+                logger.Warn($"Failed to get {nameof(FindPackageByIdResource)} for [{source.Source}]");
                 continue;
             }
 
@@ -100,7 +111,21 @@ internal static class VersionFinder
                 result.AddCurrentVersionSource(source);
             }
 
-            result.AddRange(source, feedVersions.Where(versionFilter));
+            var versions = feedVersions.Where(versionFilter).ToArray();
+            foreach (var version in versions)
+            {
+                var isTfmCompatible = await CompatibilityChecker.CheckAsync(
+                    new PackageIdentity(packageId, version),
+                    projectTfms,
+                    nugetContext,
+                    logger,
+                    CancellationToken.None);
+                if (isTfmCompatible || projectTfms.IsEmpty)
+                {
+                    // dotnet-tools.json and global.json packages won't specify a TFM, so they're always compatible
+                    result.Add(source, version);
+                }
+            }
         }
 
         return result;

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/VersionResult.cs

@@ -22,18 +22,15 @@ internal class VersionResult
         _currentVersionSources.Add(source);
     }
 
-    public void AddRange(PackageSource source, IEnumerable<NuGetVersion> versions)
+    public void Add(PackageSource source, NuGetVersion version)
     {
-        foreach (var version in versions)
+        if (_versions.ContainsKey(version))
         {
-            if (_versions.ContainsKey(version))
-            {
-                _versions[version].Add(source);
-            }
-            else
-            {
-                _versions.Add(version, [source]);
-            }
+            _versions[version].Add(source);
+        }
+        else
+        {
+            _versions.Add(version, [source]);
         }
     }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/DependencyDiscovery.props

@@ -2,6 +2,7 @@
   <!-- The following properties enable target framework and dependency discovery when OS-specific workloads are required -->
   <PropertyGroup>
     <DesignTimeBuild>true</DesignTimeBuild>
-    <TargetPlatformVersion Condition=" $(TargetFramework.Contains('-')) ">1.0</TargetPlatformVersion>
+    <EnableWindowsTargeting>true</EnableWindowsTargeting>
+    <TargetPlatformVersion Condition="$(TargetPlatformVersion) == '' AND $(TargetFramework.Contains('-'))">1.0</TargetPlatformVersion>
   </PropertyGroup>
 </Project>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/ClosePullRequest.cs

@@ -0,0 +1,12 @@
+using System.Collections.Immutable;
+using System.Text.Json.Serialization;
+
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public sealed record ClosePullRequest
+{
+    [JsonPropertyName("dependency-names")]
+    public required ImmutableArray<string> DependencyNames { get; init; }
+
+    public string Reason { get; init; } = "up_to_date";
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/PullRequestExistsForLatestVersion.cs

@@ -0,0 +1,11 @@
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public record PullRequestExistsForLatestVersion : JobErrorBase
+{
+    public PullRequestExistsForLatestVersion(string dependencyName, string dependencyVersion)
+        : base("pull_request_exists_for_latest_version")
+    {
+        Details["dependency-name"] = dependencyName;
+        Details["dependency-version"] = dependencyVersion;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/SecurityUpdateNotNeeded.cs

@@ -0,0 +1,10 @@
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public record SecurityUpdateNotNeeded : JobErrorBase
+{
+    public SecurityUpdateNotNeeded(string dependencyName)
+        : base("security_update_not_needed")
+    {
+        Details["dependency-name"] = dependencyName;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/UpdatePullRequest.cs

@@ -0,0 +1,28 @@
+using System.Collections.Immutable;
+using System.Text.Json.Serialization;
+
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public sealed record UpdatePullRequest
+{
+    [JsonPropertyName("base-commit-sha")]
+    public required string BaseCommitSha { get; init; }
+
+    [JsonPropertyName("dependency-names")]
+    public required ImmutableArray<string> DependencyNames { get; init; }
+
+    [JsonPropertyName("updated-dependency-files")]
+    public required DependencyFile[] UpdatedDependencyFiles { get; init; }
+
+    [JsonPropertyName("pr-title")]
+    public required string PrTitle { get; init; }
+
+    [JsonPropertyName("pr-body")]
+    public required string PrBody { get; init; }
+
+    [JsonPropertyName("commit-message")]
+    public required string CommitMessage { get; init; }
+
+    [JsonPropertyName("dependency-group")]
+    public required string? DependencyGroup { get; init; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/HttpApiHandler.cs

@@ -45,6 +45,11 @@ public class HttpApiHandler : IApiHandler
         await PostAsJson("create_pull_request", createPullRequest);
     }
 
+    public async Task UpdatePullRequest(UpdatePullRequest updatePullRequest)
+    {
+        await PostAsJson("update_pull_request", updatePullRequest);
+    }
+
     public async Task MarkAsProcessed(MarkAsProcessed markAsProcessed)
     {
         await PostAsJson("mark_as_processed", markAsProcessed);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/IApiHandler.cs

@@ -8,5 +8,6 @@ public interface IApiHandler
     Task UpdateDependencyList(UpdatedDependencyList updatedDependencyList);
     Task IncrementMetric(IncrementMetric incrementMetric);
     Task CreatePullRequest(CreatePullRequest createPullRequest);
+    Task UpdatePullRequest(UpdatePullRequest updatePullRequest);
     Task MarkAsProcessed(MarkAsProcessed markAsProcessed);
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/RunWorker.cs

@@ -11,6 +11,7 @@ using NuGet.Versioning;
 using NuGetUpdater.Core.Analyze;
 using NuGetUpdater.Core.Discover;
 using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Utilities;
 
 namespace NuGetUpdater.Core.Run;
 
@@ -116,14 +117,12 @@ public class RunWorker
         var discoveredUpdatedDependencies = GetUpdatedDependencyListFromDiscovery(discoveryResult, repoContentsPath.FullName);
         await _apiHandler.UpdateDependencyList(discoveredUpdatedDependencies);
 
+        var incrementMetric = GetIncrementMetric(job);
+        await _apiHandler.IncrementMetric(incrementMetric);
+
         // TODO: pull out relevant dependencies, then check each for updates and track the changes
         var originalDependencyFileContents = new Dictionary<string, string>();
         var actualUpdatedDependencies = new List<ReportedDependency>();
-        await _apiHandler.IncrementMetric(new()
-        {
-            Metric = "updater.started",
-            Tags = { ["operation"] = "group_update_all_versions" },
-        });
 
         // track original contents for later handling
         async Task TrackOriginalContentsAsync(string directory, string fileName)
@@ -147,59 +146,51 @@ public class RunWorker
         }
 
         // do update
-        _logger.Info($"Running update in directory {repoDirectory}");
-        foreach (var project in discoveryResult.Projects)
+        var updateOperations = GetUpdateOperations(discoveryResult).ToArray();
+        foreach (var updateOperation in updateOperations)
         {
-            foreach (var dependency in project.Dependencies)
+            var dependency = updateOperation.Dependency;
+            if (!IsUpdateAllowed(job, dependency))
             {
-                if (!IsUpdateAllowed(job, dependency))
-                {
-                    continue;
-                }
+                continue;
+            }
+
+            _logger.Info($"Updating [{dependency.Name}] in [{updateOperation.ProjectPath}]");
 
-                var dependencyInfo = GetDependencyInfo(job, dependency);
-                var analysisResult = await _analyzeWorker.RunAsync(repoContentsPath.FullName, discoveryResult, dependencyInfo);
-                // TODO: log analysisResult
-                if (analysisResult.CanUpdate)
+            var dependencyInfo = GetDependencyInfo(job, dependency);
+            var analysisResult = await _analyzeWorker.RunAsync(repoContentsPath.FullName, discoveryResult, dependencyInfo);
+            // TODO: log analysisResult
+            if (analysisResult.CanUpdate)
+            {
+                // TODO: this is inefficient, but not likely causing a bottleneck
+                var previousDependency = discoveredUpdatedDependencies.Dependencies
+                    .Single(d => d.Name == dependency.Name && d.Requirements.Single().File == updateOperation.ProjectPath);
+                var updatedDependency = new ReportedDependency()
                 {
-                    var dependencyLocation = Path.Join(discoveryResult.Path, project.FilePath).FullyNormalizedRootedPath();
-
-                    // TODO: this is inefficient, but not likely causing a bottleneck
-                    var previousDependency = discoveredUpdatedDependencies.Dependencies
-                        .Single(d => d.Name == dependency.Name && d.Requirements.Single().File == dependencyLocation);
-                    var updatedDependency = new ReportedDependency()
-                    {
-                        Name = dependency.Name,
-                        Version = analysisResult.UpdatedVersion,
-                        Requirements =
-                        [
-                            new ReportedRequirement()
-                            {
-                                File = dependencyLocation,
-                                Requirement = analysisResult.UpdatedVersion,
-                                Groups = previousDependency.Requirements.Single().Groups,
-                                Source = new RequirementSource()
-                                {
-                                    SourceUrl = analysisResult.UpdatedDependencies.FirstOrDefault(d => d.Name == dependency.Name)?.InfoUrl,
-                                },
-                            }
-                        ],
-                        PreviousVersion = dependency.Version,
-                        PreviousRequirements = previousDependency.Requirements,
-                    };
-
-                    var dependencyFilePath = Path.Join(discoveryResult.Path, project.FilePath).FullyNormalizedRootedPath();
-                    var updateResult = await _updaterWorker.RunAsync(repoContentsPath.FullName, dependencyFilePath, dependency.Name, dependency.Version!, analysisResult.UpdatedVersion, isTransitive: dependency.IsTransitive);
-                    // TODO: need to report if anything was actually updated
-                    if (updateResult.Error is null)
-                    {
-                        if (dependencyLocation != dependencyFilePath)
+                    Name = dependency.Name,
+                    Version = analysisResult.UpdatedVersion,
+                    Requirements =
+                    [
+                        new ReportedRequirement()
                         {
-                            updatedDependency.Requirements.All(r => r.File == dependencyFilePath);
+                            File = updateOperation.ProjectPath,
+                            Requirement = analysisResult.UpdatedVersion,
+                            Groups = previousDependency.Requirements.Single().Groups,
+                            Source = new RequirementSource()
+                            {
+                                SourceUrl = analysisResult.UpdatedDependencies.FirstOrDefault(d => d.Name == dependency.Name)?.InfoUrl,
+                            },
                         }
+                    ],
+                    PreviousVersion = dependency.Version,
+                    PreviousRequirements = previousDependency.Requirements,
+                };
 
-                        actualUpdatedDependencies.Add(updatedDependency);
-                    }
+                var updateResult = await _updaterWorker.RunAsync(repoContentsPath.FullName, updateOperation.ProjectPath, dependency.Name, dependency.Version!, analysisResult.UpdatedVersion, isTransitive: dependency.IsTransitive);
+                // TODO: need to report if anything was actually updated
+                if (updateResult.Error is null)
+                {
+                    actualUpdatedDependencies.Add(updatedDependency);
                 }
             }
         }
@@ -275,6 +266,52 @@ public class RunWorker
         return result;
     }
 
+    internal static IEnumerable<(string ProjectPath, Dependency Dependency)> GetUpdateOperations(WorkspaceDiscoveryResult discovery)
+    {
+        // discovery is grouped by project then dependency, but we want to pivot and return a list of update operations sorted by dependency name then project path
+
+        var updateOrder = new Dictionary<string, Dictionary<string, Dictionary<string, Dependency>>>(StringComparer.OrdinalIgnoreCase);
+        //                     <dependency name,     <project path, specific dependencies>>
+
+        // collect
+        foreach (var project in discovery.Projects)
+        {
+            var projectPath = Path.Join(discovery.Path, project.FilePath).FullyNormalizedRootedPath();
+            foreach (var dependency in project.Dependencies)
+            {
+                var dependencyGroup = updateOrder.GetOrAdd(dependency.Name, () => new Dictionary<string, Dictionary<string, Dependency>>(PathComparer.Instance));
+                var dependenciesForProject = dependencyGroup.GetOrAdd(projectPath, () => new Dictionary<string, Dependency>(StringComparer.OrdinalIgnoreCase));
+                dependenciesForProject[dependency.Name] = dependency;
+            }
+        }
+
+        // return
+        foreach (var dependencyName in updateOrder.Keys.OrderBy(k => k, StringComparer.OrdinalIgnoreCase))
+        {
+            var projectDependencies = updateOrder[dependencyName];
+            foreach (var projectPath in projectDependencies.Keys.OrderBy(p => p, PathComparer.Instance))
+            {
+                var dependencies = projectDependencies[projectPath];
+                var dependency = dependencies[dependencyName];
+                yield return (projectPath, dependency);
+            }
+        }
+    }
+
+    internal static IncrementMetric GetIncrementMetric(Job job)
+    {
+        var isSecurityUpdate = job.AllowedUpdates.Any(a => a.UpdateType == UpdateType.Security) || job.SecurityUpdatesOnly;
+        var metricOperation = isSecurityUpdate ?
+            (job.UpdatingAPullRequest ? "update_security_pr" : "create_security_pr")
+            : (job.UpdatingAPullRequest ? "update_version_pr" : "group_update_all_versions");
+        var increment = new IncrementMetric()
+        {
+            Metric = "updater.started",
+            Tags = { ["operation"] = metricOperation },
+        };
+        return increment;
+    }
+
     internal static bool IsUpdateAllowed(Job job, Dependency dependency)
     {
         if (dependency.Name.Equals("Microsoft.NET.Sdk", StringComparison.OrdinalIgnoreCase))
@@ -409,23 +446,28 @@ public class RunWorker
             .Distinct()
             .OrderBy(p => p)
             .ToArray();
+        var orderedProjects = discoveryResult.Projects
+            .OrderBy(p => Path.Join(discoveryResult.Path, p.FilePath).FullyNormalizedRootedPath(), PathComparer.Instance)
+            .ToArray();
         var updatedDependencyList = new UpdatedDependencyList()
         {
-            Dependencies = discoveryResult.Projects.SelectMany(p =>
+            Dependencies = orderedProjects.SelectMany(p =>
             {
-                return p.Dependencies.Where(d => d.Version is not null).Select(d =>
-                    new ReportedDependency()
-                    {
-                        Name = d.Name,
-                        Requirements = [new ReportedRequirement()
+                return p.Dependencies
+                    .Where(d => d.Version is not null)
+                    .OrderBy(d => d.Name, StringComparer.OrdinalIgnoreCase)
+                    .Select(d =>
+                        new ReportedDependency()
                         {
-                            File = GetFullRepoPath(p.FilePath),
-                            Requirement = d.Version!,
-                            Groups = ["dependencies"],
-                        }],
-                        Version = d.Version,
-                    }
-                );
+                            Name = d.Name,
+                            Requirements = [new ReportedRequirement()
+                            {
+                                File = GetFullRepoPath(p.FilePath),
+                                Requirement = d.Version!,
+                                Groups = ["dependencies"],
+                            }],
+                            Version = d.Version,
+                        });
             }).ToArray(),
             DependencyFiles = dependencyFiles,
         };

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/TargetFrameworkReporter.targets

@@ -2,12 +2,7 @@
   <Import Project="DependencyDiscovery.props" />
 
   <Target Name="ReportTargetFramework">
-    <!-- this property is for non-SDK projects, commonly with `packages.config -->
-    <!-- e.g., returns ".NETFramework,Version=v4.5" -->
-    <Message Text="ProjectData::TargetFrameworkVersion=$(TargetFrameworkIdentifier),Version=$(TargetFrameworkVersion)" Importance="High" Condition="'$(TargetFrameworkIdentifier)' != '' AND '' != '$(TargetFrameworkVersion)'" />
-
-    <!-- these properties are for SDK projects -->
-    <Message Text="ProjectData::TargetFramework=$(TargetFramework)" Importance="High" Condition="'$(TargetFramework)' != ''" />
+    <Message Text="ProjectData::TargetFrameworkMoniker=$(TargetFrameworkMoniker);ProjectData::TargetPlatformMoniker=$(TargetPlatformMoniker)" Importance="High" Condition="'$(TargetFrameworkMoniker)' != ''" />
     <Message Text="ProjectData::TargetFrameworks=$(TargetFrameworks)" Importance="High" Condition="'$(TargetFrameworks)' != ''" />
   </Target>
 </Project>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/DependencyConflictResolver.cs

@@ -420,6 +420,8 @@ public class PackageManager
                     }
                 }
 
+                var projectFramework = NuGetFramework.Parse(targetFramework);
+
                 // Get the parent packages of the package and check the compatibility between its family
                 HashSet<PackageToUpdate> parentPackages = GetParentPackages(package);
 
@@ -458,7 +460,7 @@ public class PackageManager
                             string currentVersionString = parent.CurrentVersion;
                             NuGetVersion currentVersionParent = NuGetVersion.Parse(currentVersionString);
 
-                            var result = await VersionFinder.GetVersionsAsync(parent.PackageName, currentVersionParent, nugetContext, logger, CancellationToken.None);
+                            var result = await VersionFinder.GetVersionsAsync([projectFramework], parent.PackageName, currentVersionParent, nugetContext, logger, CancellationToken.None);
                             var versions = result.GetVersions();
                             NuGetVersion latestVersion = versions.Where(v => !v.IsPrerelease).Max();
 
@@ -565,8 +567,9 @@ public class PackageManager
 
         // Create a NugetContext instance to get the latest versions of the parent
         NuGetContext nugetContext = new NuGetContext(Path.GetDirectoryName(projectPath));
+        var projectFramework = NuGetFramework.Parse(targetFramework);
 
-        var result = await VersionFinder.GetVersionsAsync(possibleParent.PackageName, CurrentVersion, nugetContext, logger, CancellationToken.None);
+        var result = await VersionFinder.GetVersionsAsync([projectFramework], possibleParent.PackageName, CurrentVersion, nugetContext, logger, CancellationToken.None);
         var versions = result.GetVersions();
 
         // If there are no versions

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/MSBuildHelper.cs

@@ -801,40 +801,51 @@ internal static partial class MSBuildHelper
             logger.Warn($"Error determining target frameworks.\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
         }
 
-        // There are 3 return values, all uses slightly differently.  Only one will be set, the others will be blank
-        //   ProjectData::TargetFrameworkVersion=.NETFramework,Version=v4.5     // non-SDK projects, commonly with `packages.config`
-        //   ProjectData::TargetFramework=net7.0                                // SDK-style projects
-        //   ProjectData::TargetFrameworks=net7.0;net8.0
-        var tfmPatterns = new Regex[]
+        // There are 2 possible return values:
+        //   1. For SDK-style projects with a single TFM and legacy projects the output will look like:
+        //      ProjectData::TargetFrameworkMoniker=.NETCoreApp,Version=8.0;ProjectData::TargetPlatformMoniker=Windows,Version=7.0
+        //   2. For SDK-style projects with multiple TFMs the output will look like:
+        //      ProjectData::TargetFrameworks=net8.0;net9.0
+        var listedTargetFrameworks = new List<ValueTuple<string, string>>();
+        var listedTfmMatch = Regex.Match(stdOut, "ProjectData::TargetFrameworks=(?<TargetFrameworks>.*)$", RegexOptions.Multiline);
+        if (listedTfmMatch.Success)
         {
-            new Regex("ProjectData::TargetFrameworkVersion=(?<Value>.*)$", RegexOptions.Multiline),
-            new Regex("ProjectData::TargetFramework=(?<Value>.*)$", RegexOptions.Multiline),
-            new Regex("ProjectData::TargetFrameworks=(?<Value>.*)$", RegexOptions.Multiline),
-        };
-        var tfms = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-        foreach (var tfmPattern in tfmPatterns)
+            var value = listedTfmMatch.Groups["TargetFrameworks"].Value;
+            var foundTfms = value.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+                .Select(tfm => ValueTuple.Create(tfm, string.Empty))
+                .ToArray();
+            listedTargetFrameworks.AddRange(foundTfms);
+        }
+
+        var individualTfmMatch = Regex.Match(stdOut, "ProjectData::TargetFrameworkMoniker=(?<TargetFrameworkMoniker>[^;]*);ProjectData::TargetPlatformMoniker=(?<TargetPlatformMoniker>.*)$", RegexOptions.Multiline);
+        if (individualTfmMatch.Success)
         {
-            var candidateTfms = tfmPattern.Matches(stdOut)
-                .Select(m => m.Groups["Value"].Value)
-                .SelectMany(v => v.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
-                .Where(v => !string.IsNullOrWhiteSpace(v))
-                .Select(v =>
-                {
-                    try
-                    {
-                        var framework = NuGetFramework.Parse(v);
-                        return framework.GetShortFolderName();
-                    }
-                    catch
-                    {
-                        return string.Empty;
-                    }
-                })
-                .Where(tfm => !string.IsNullOrEmpty(tfm));
-            tfms.AddRange(candidateTfms);
+            var tfm = individualTfmMatch.Groups["TargetFrameworkMoniker"].Value;
+            var tpm = individualTfmMatch.Groups["TargetPlatformMoniker"].Value;
+            listedTargetFrameworks.Add(ValueTuple.Create(tfm, tpm));
         }
 
-        return tfms.ToImmutableArray();
+        var tfms = listedTargetFrameworks.Select(tfpm =>
+            {
+                try
+                {
+                    // Item2 is an optional component that looks like: "Windows,Version=7.0"
+                    var framework = string.IsNullOrWhiteSpace(tfpm.Item2)
+                        ? NuGetFramework.Parse(tfpm.Item1)
+                        : NuGetFramework.ParseComponents(tfpm.Item1, tfpm.Item2);
+                    return framework;
+                }
+                catch
+                {
+                    return null;
+                }
+            })
+            .Where(tfm => tfm is not null)
+            .Select(tfm => tfm!.GetShortFolderName())
+            .OrderBy(tfm => tfm)
+            .ToImmutableArray();
+
+        return tfms;
     }
 
     internal static async Task<Dependency[]> GetAllPackageDependenciesAsync(

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/PathComparer.cs

@@ -2,28 +2,35 @@ using System.Diagnostics.CodeAnalysis;
 
 namespace NuGetUpdater.Core.Utilities;
 
-public class PathComparer : IEqualityComparer<string>
+public class PathComparer : IComparer<string>, IEqualityComparer<string>
 {
     public static PathComparer Instance { get; } = new PathComparer();
 
-    public bool Equals(string? x, string? y)
+    public int Compare(string? x, string? y)
     {
         x = x?.NormalizePathToUnix();
         y = y?.NormalizePathToUnix();
 
         if (x is null && y is null)
         {
-            return true;
+            return 0;
         }
 
-        if (x is null || y is null)
+        if (x is null)
         {
-            return false;
+            return -1;
         }
 
-        return x.Equals(y, StringComparison.OrdinalIgnoreCase);
+        if (y is null)
+        {
+            return 1;
+        }
+
+        return x.CompareTo(y);
     }
 
+    public bool Equals(string? x, string? y) => Compare(x, y) == 0;
+
     public int GetHashCode([DisallowNull] string obj)
     {
         return obj.NormalizePathToUnix().GetHashCode();