Add Nuget package version resolver

DotNetSolutionTools.App/ViewModels/MainWindowViewModel.cs

@@ -157,6 +157,27 @@ public partial class MainWindowViewModel : ObservableObject
         }
     }
 
+    [RelayCommand]
+    private async Task ResolveInconsistentNugetPackageVersionsInSolutionFile(CancellationToken token)
+    {
+        SetBeginCommandState();
+        try
+        {
+            await Task.Run(
+                () =>
+                {
+                    PackageVersionConsistency.ResolvePackageVersionsToLatestInstalled(SolutionFilePath);
+                    SetCommandSuccessState("Resolved all packages with inconsistent versions");
+                },
+                token
+            );
+        }
+        catch (Exception e)
+        {
+            SetCommandFailureState("Failed to resolve inconsistent package versions in solution file", e);
+        }
+    }
+
     [RelayCommand]
     private async Task CheckForInconsistentNugetPackageVersionsInSolutionFile(CancellationToken token)
     {

DotNetSolutionTools.App/Views/MainWindow.axaml

@@ -127,6 +127,15 @@
                         Check for Inconsistent Nuget Package Versions
                     </TextBlock>
                 </Button>
+                <Button Grid.Row="3" Grid.Column="1" MinHeight="100" Padding="10" Margin="5"
+                        HorizontalAlignment="Stretch" VerticalAlignment="Stretch"
+                        VerticalContentAlignment="Center" HorizontalContentAlignment="Center"
+                        IsEnabled="{Binding SolutionFilePath, Mode=OneWay, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"
+                        Command="{Binding ResolveInconsistentNugetPackageVersionsInSolutionFileCommand}">
+                    <TextBlock TextWrapping="Wrap">
+                        Resolve Inconsistent Nuget Package Versions
+                    </TextBlock>
+                </Button>
             </Grid>
         <Label Width="{Binding $parent.Bounds.Width}" Background="{Binding ResultsLabelColor}" HorizontalAlignment="Center" HorizontalContentAlignment="Center" Name="ResultsLabel" Content="{Binding ResultsLabel}"></Label>
        </StackPanel>

DotNetSolutionTools.Core/PackageVersionConsistency.cs

@@ -6,24 +6,45 @@ namespace DotNetSolutionTools.Core;
 
 public class PackageVersionConsistency
 {
+    public static void ResolvePackageVersionsToLatestInstalled(string solutionFilePath)
+    {
+        var result = GetInconsistentNugetPackageVersions(solutionFilePath);
+        var inconsistentPackages = result
+            .GroupBy(s => s.packageName)
+            .Select(s =>
+                (s.Key, s.Select(x => (x.version, x.metadataElement)).OrderByDescending(x => x.version).ToList())
+            )
+            .ToList();
+
+        foreach (var package in inconsistentPackages)
+        {
+            var latestInstalledVersion = package.Item2.First().version;
+            foreach (var (version, metadataElement) in package.Item2.Skip(1))
+            {
+                metadataElement.Value = latestInstalledVersion.ToString();
+                metadataElement.ContainingProject.Save();
+                FormatCsproj.FormatCsprojFile(metadataElement.ContainingProject.FullPath);
+            }
+        }
+    }
+
     public static List<string> FindInconsistentNugetPackageVersions(string solutionFilePath)
+    {
+        var result = GetInconsistentNugetPackageVersions(solutionFilePath);
+        return result.Select(s => s.packageName).Distinct().ToList();
+    }
+
+    private static List<(
+        string packageName,
+        NuGetVersion version,
+        ProjectMetadataElement metadataElement
+    )> GetInconsistentNugetPackageVersions(string solutionFilePath)
     {
         var solutionFile = SolutionFile.Parse(solutionFilePath);
         var csprojList = SlnHelper.GetCSharpProjectObjectsFromSolutionFile(solutionFile);
-        var packageList = new List<(string, NuGetVersion)>();
+        var packageList = new List<(string, NuGetVersion, ProjectMetadataElement)>();
-        //var packageListConcurrent = new ConcurrentBag<(string, NuGetVersion)>();
+        var outOfSyncPackages = new List<(string packageName, NuGetVersion version, ProjectMetadataElement element)>();
-        var outOfSyncPackages = new List<(string packageName, NuGetVersion version)>();
+
-        // Parallel.ForEach(
-        //     csprojList,
-        //     project =>
-        //     {
-        //         var projectPackages = GetPackageVersions(project);
-        //         lock (packageList)
-        //         {
-        //             packageList.AddRange(projectPackages);
-        //         }
-        //     }
-        // );
         foreach (var project in csprojList)
         {
             var projectPackages = GetPackageVersions(project);
@@ -31,22 +52,20 @@ public class PackageVersionConsistency
         }
 
         var groupedByPackage = packageList.GroupBy(s => s.Item1).ToList();
-        foreach (var package in groupedByPackage)
+        foreach (var grouping in groupedByPackage)
         {
-            var versions = package.Select(s => s.Item2).Distinct().ToList();
+            var versions = grouping.Select(s => (s.Item2, s.Item3)).DistinctBy(s => s.Item1).ToList();
             if (versions.Count > 1)
             {
-                outOfSyncPackages.Add((package.Key, versions.First()));
+                //outOfSyncPackages.AddRange(versions.Select(s => (grouping.Key, s.Item1, s.Item2)));
+                outOfSyncPackages.AddRange(grouping.Select(s => (s.Item1, s.Item2, s.Item3)));
             }
         }
 
-        Console.WriteLine("Logging out of sync packages");
+        return outOfSyncPackages.ToList();
-        outOfSyncPackages.ForEach(s => Console.WriteLine(s.packageName));
-
-        return outOfSyncPackages.Select(s => s.packageName).ToList();
     }
 
-    private static List<(string, NuGetVersion)> GetPackageVersions(ProjectRootElement project)
+    private static List<(string, NuGetVersion, ProjectMetadataElement)> GetPackageVersions(ProjectRootElement project)
     {
         try
         {
@@ -55,7 +74,13 @@ public class PackageVersionConsistency
                 .ToList();
 
             var packageNameAndVersion = packages
-                .Select(x => (x.Include, NuGetVersion.Parse(x.Metadata.First(s => s.Name == "Version").Value)))
+                .Select(x =>
+                    (
+                        x.Include,
+                        NuGetVersion.Parse(x.Metadata.First(s => s.Name == "Version").Value),
+                        x.Metadata.First(s => s.Name == "Version")
+                    )
+                )
                 .ToList();
             return packageNameAndVersion;
         }