dependabot-nuget 0.280.0 → 0.282.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/BindingRedirectManager.cs

@@ -18,6 +18,16 @@ internal static class BindingRedirectManager
     private static readonly XName DependentAssemblyName = AssemblyBinding.GetQualifiedName("dependentAssembly");
     private static readonly XName BindingRedirectName = AssemblyBinding.GetQualifiedName("bindingRedirect");
 
+    /// <summary>
+    /// Updates assembly binding redirects for a project build file.
+    /// </summary>
+    /// <remarks>
+    /// Assembly binding redirects are only applicable to projects targeting .NET Framework.
+    /// .NET Framework targets can appear in SDK-style OR non-SDK-style project files, using either packages.config OR `<PackageReference>` MSBuild items.
+    /// See: https://learn.microsoft.com/en-us/dotnet/framework/configure-apps/redirect-assembly-versions
+    ///      https://learn.microsoft.com/en-us/nuget/resources/check-project-format
+    /// </remarks>
+    /// <param name="projectBuildFile">The project build file (*.xproj) to be updated</param>
     public static async ValueTask UpdateBindingRedirectsAsync(ProjectBuildFile projectBuildFile)
     {
         var configFile = await TryGetRuntimeConfigurationFile(projectBuildFile);
@@ -33,7 +43,7 @@ internal static class BindingRedirectManager
         var bindings = BindingRedirectResolver.GetBindingRedirects(projectBuildFile.Path, references.Select(static x => x.Include));
         if (!bindings.Any())
         {
-            // no bindings to update
+            // no bindings found in the project file, nothing to update
             return;
         }
 
@@ -116,19 +126,19 @@ internal static class BindingRedirectManager
             return null;
         }
 
-        var configFilePath = Path.GetFullPath(Path.Combine(directoryPath, GetContent(configFile)));
+        var configFilePath = Path.GetFullPath(Path.Combine(directoryPath, GetValue(configFile)));
         var configFileContents = await File.ReadAllTextAsync(configFilePath);
         return new ConfigurationFile(configFilePath, configFileContents, false);
 
-        static string GetContent(IXmlElementSyntax element)
+        static string GetValue(IXmlElementSyntax element)
         {
-            var content = element.GetContentValue();
+            var content = element.GetAttributeValue("Include");
             if (!string.IsNullOrEmpty(content))
             {
                 return content;
             }
 
-            content = element.GetAttributeValue("Include");
+            content = element.GetContentValue();
             if (!string.IsNullOrEmpty(content))
             {
                 return content;
@@ -139,7 +149,7 @@ internal static class BindingRedirectManager
 
         static bool IsConfigFile(IXmlElementSyntax element)
         {
-            var content = GetContent(element);
+            var content = GetValue(element);
             if (content is null)
             {
                 return false;

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/DotNetToolsJsonUpdater.cs

@@ -8,7 +8,7 @@ internal static class DotNetToolsJsonUpdater
         string dependencyName,
         string previousDependencyVersion,
         string newDependencyVersion,
-        Logger logger)
+        ILogger logger)
     {
         if (!MSBuildHelper.TryGetDotNetToolsJsonPath(repoRootPath, workspacePath, out var dotnetToolsJsonPath))
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/GlobalJsonUpdater.cs

@@ -8,7 +8,7 @@ internal static class GlobalJsonUpdater
         string dependencyName,
         string previousDependencyVersion,
         string newDependencyVersion,
-        Logger logger)
+        ILogger logger)
     {
         if (!MSBuildHelper.TryGetGlobalJsonPath(repoRootPath, workspacePath, out var globalJsonPath))
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/LockFileUpdater.cs

@@ -5,7 +5,7 @@ internal static class LockFileUpdater
     public static async Task UpdateLockFileAsync(
         string repoRootPath,
         string projectPath,
-        Logger logger)
+        ILogger logger)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath);
         var lockPath = Path.Combine(projectDirectory, "packages.lock.json");
@@ -23,6 +23,6 @@ internal static class LockFileUpdater
             {
                 logger.Log($"      Lock file update failed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
             }
-        }, retainMSBuildSdks: true);
+        }, logger, retainMSBuildSdks: true);
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/{SdkPackageUpdater.cs → PackageReferenceUpdater.cs}

@@ -6,7 +6,18 @@ using NuGet.Versioning;
 
 namespace NuGetUpdater.Core;
 
-internal static class SdkPackageUpdater
+/// <summary>
+/// Handles package updates for projects containing `<PackageReference>` MSBuild items.
+/// </summary>
+/// <remarks>
+/// PackageReference items can appear in both SDK-style AND non-SDK-style project files.
+/// By default, PackageReference is used by [SDK-style] projects targeting .NET Core, .NET Standard, and UWP.
+/// By default, packages.config is used by [non-SDK-style] projects targeting .NET Framework; However, they can be migrated to PackageReference too.
+/// See: https://learn.microsoft.com/en-us/nuget/consume-packages/package-references-in-project-files#project-type-support
+///      https://learn.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+///      https://learn.microsoft.com/en-us/nuget/resources/check-project-format
+/// </remarks>
+internal static class PackageReferenceUpdater
 {
     public static async Task UpdateDependencyAsync(
         string repoRootPath,
@@ -15,10 +26,10 @@ internal static class SdkPackageUpdater
         string previousDependencyVersion,
         string newDependencyVersion,
         bool isTransitive,
-        Logger logger)
+        ILogger logger)
     {
-        // SDK-style project, modify the XML directly
-        logger.Log("  Running for SDK-style project");
+        // PackageReference project; modify the XML directly
+        logger.Log("  Running 'PackageReference' project direct XML update");
 
         (ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
 
@@ -30,19 +41,26 @@ internal static class SdkPackageUpdater
             return;
         }
 
-        if (isTransitive)
+        var peerDependencies = await GetUpdatedPeerDependenciesAsync(repoRootPath, projectPath, tfms, dependencyName, newDependencyVersion, logger);
+        if (MSBuildHelper.UseNewDependencySolver())
         {
-            await UpdateTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, buildFiles, logger);
+            await UpdateDependencyWithConflictResolution(repoRootPath, buildFiles, tfms, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, peerDependencies, logger);
         }
         else
         {
-            var peerDependencies = await GetUpdatedPeerDependenciesAsync(repoRootPath, projectPath, tfms, dependencyName, newDependencyVersion, logger);
-            if (peerDependencies is null)
+            if (isTransitive)
             {
-                return;
+                await UpdateTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, buildFiles, logger);
             }
+            else
+            {
+                if (peerDependencies is null)
+                {
+                    return;
+                }
 
-            await UpdateTopLevelDepdendency(repoRootPath, buildFiles, tfms, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, logger);
+                await UpdateTopLevelDepdendency(repoRootPath, buildFiles, tfms, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, logger);
+            }
         }
 
         if (!await AreDependenciesCoherentAsync(repoRootPath, projectPath, dependencyName, logger, buildFiles, tfms))
@@ -53,6 +71,61 @@ internal static class SdkPackageUpdater
         await SaveBuildFilesAsync(buildFiles, logger);
     }
 
+    public static async Task UpdateDependencyWithConflictResolution(
+        string repoRootPath,
+        ImmutableArray<ProjectBuildFile> buildFiles,
+        string[] targetFrameworks,
+        string projectPath,
+        string dependencyName,
+        string previousDependencyVersion,
+        string newDependencyVersion,
+        bool isTransitive,
+        IDictionary<string, string> peerDependencies,
+        ILogger logger)
+    {
+        var topLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
+        var isDependencyTopLevel = topLevelDependencies.Any(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase));
+        var dependenciesToUpdate = new[] { new Dependency(dependencyName, newDependencyVersion, DependencyType.PackageReference) };
+
+        // update the initial dependency...
+        TryUpdateDependencyVersion(buildFiles, dependencyName, previousDependencyVersion, newDependencyVersion, logger);
+
+        // ...and the peer dependencies...
+        foreach (var (packageName, packageVersion) in peerDependencies.Where(kvp => string.Compare(kvp.Key, dependencyName, StringComparison.OrdinalIgnoreCase) != 0))
+        {
+            TryUpdateDependencyVersion(buildFiles, packageName, previousDependencyVersion: null, newDependencyVersion: packageVersion, logger);
+        }
+
+        // ...and everything else
+        foreach (var projectFile in buildFiles)
+        {
+            foreach (var tfm in targetFrameworks)
+            {
+                var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRootPath, projectFile.Path, tfm, topLevelDependencies, dependenciesToUpdate, logger);
+                if (resolvedDependencies is null)
+                {
+                    logger.Log($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
+                    continue;
+                }
+
+                var isDependencyInResolutionSet = resolvedDependencies.Any(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase));
+                if (isTransitive && !isDependencyTopLevel && isDependencyInResolutionSet)
+                {
+                    // a transitive dependency had to be pinned; add it here
+                    await UpdateTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, buildFiles, logger);
+                }
+
+                // update all resolved dependencies that aren't the initial dependency
+                foreach (var resolvedDependency in resolvedDependencies
+                                                    .Where(d => !d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase))
+                                                    .Where(d => d.Version is not null))
+                {
+                    TryUpdateDependencyVersion(buildFiles, resolvedDependency.Name, previousDependencyVersion: null, newDependencyVersion: resolvedDependency.Version!, logger);
+                }
+            }
+        }
+    }
+
     /// <summary>
     /// Verifies that the package does not already satisfy the requested dependency version.
     /// </summary>
@@ -64,7 +137,7 @@ internal static class SdkPackageUpdater
         Dependency[] topLevelDependencies,
         string dependencyName,
         string newDependencyVersion,
-        Logger logger)
+        ILogger logger)
     {
         var newDependencyNuGetVersion = NuGetVersion.Parse(newDependencyVersion);
 
@@ -124,7 +197,7 @@ internal static class SdkPackageUpdater
         return true;
     }
 
-    private static async Task UpdateTransitiveDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string newDependencyVersion, ImmutableArray<ProjectBuildFile> buildFiles, Logger logger)
+    private static async Task UpdateTransitiveDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string newDependencyVersion, ImmutableArray<ProjectBuildFile> buildFiles, ILogger logger)
     {
         var directoryPackagesWithPinning = buildFiles.OfType<ProjectBuildFile>()
             .FirstOrDefault(bf => IsCpmTransitivePinningEnabled(bf));
@@ -160,7 +233,7 @@ internal static class SdkPackageUpdater
         return isTransitivePinningEnabled is not null && string.Equals(isTransitivePinningEnabled, "true", StringComparison.OrdinalIgnoreCase);
     }
 
-    private static void PinTransitiveDependency(ProjectBuildFile directoryPackages, string dependencyName, string newDependencyVersion, Logger logger)
+    private static void PinTransitiveDependency(ProjectBuildFile directoryPackages, string dependencyName, string newDependencyVersion, ILogger logger)
     {
         var existingPackageVersionElement = directoryPackages.ItemNodes
             .Where(e => e.Name.Equals("PackageVersion", StringComparison.OrdinalIgnoreCase) &&
@@ -223,7 +296,7 @@ internal static class SdkPackageUpdater
         directoryPackages.Update(updatedXml);
     }
 
-    private static async Task AddTransitiveDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string newDependencyVersion, Logger logger)
+    private static async Task AddTransitiveDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string newDependencyVersion, ILogger logger)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath)!;
         await MSBuildHelper.SidelineGlobalJsonAsync(projectDirectory, repoRootPath, async () =>
@@ -237,7 +310,7 @@ internal static class SdkPackageUpdater
             {
                 logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
             }
-        }, retainMSBuildSdks: true);
+        }, logger, retainMSBuildSdks: true);
     }
 
     /// <summary>
@@ -250,7 +323,7 @@ internal static class SdkPackageUpdater
         string[] tfms,
         string dependencyName,
         string newDependencyVersion,
-        Logger logger)
+        ILogger logger)
     {
         var newDependency = new[] { new Dependency(dependencyName, newDependencyVersion, DependencyType.Unknown) };
         var tfmsAndDependencies = new Dictionary<string, Dependency[]>();
@@ -305,9 +378,9 @@ internal static class SdkPackageUpdater
         string previousDependencyVersion,
         string newDependencyVersion,
         IDictionary<string, string> peerDependencies,
-        Logger logger)
+        ILogger logger)
     {
-
+        // update dependencies...
         var result = TryUpdateDependencyVersion(buildFiles, dependencyName, previousDependencyVersion, newDependencyVersion, logger);
         if (result == UpdateResult.NotFound)
         {
@@ -320,26 +393,13 @@ internal static class SdkPackageUpdater
             TryUpdateDependencyVersion(buildFiles, packageName, previousDependencyVersion: null, newDependencyVersion: packageVersion, logger);
         }
 
-        // now make all dependency requirements coherent
+        // ...and make them all coherent
         Dependency[] updatedTopLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
         foreach (ProjectBuildFile projectFile in buildFiles)
         {
             foreach (string tfm in targetFrameworks)
             {
-                if (MSBuildHelper.UseNewDependencySolver())
-                {
-                    // Find the index of the dependency we are updating and revert it to the previous version
-                    int dependencyIndex = Array.FindIndex(updatedTopLevelDependencies, d => string.Equals(d.Name, dependencyName, StringComparison.OrdinalIgnoreCase));
-                    if (dependencyIndex != -1)
-                    {
-                        var originalDependency = updatedTopLevelDependencies[dependencyIndex];
-                        updatedTopLevelDependencies[dependencyIndex] = originalDependency with { Version = previousDependencyVersion };
-                    }
-
-                }
-                Dependency[] update = [new Dependency(dependencyName, newDependencyVersion, DependencyType.PackageReference)];
-                Dependency[]? resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRootPath, projectFile.Path, tfm, updatedTopLevelDependencies, update, logger);
-
+                var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflictsWithBruteForce(repoRootPath, projectFile.Path, tfm, updatedTopLevelDependencies, logger);
                 if (resolvedDependencies is null)
                 {
                     logger.Log($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
@@ -360,7 +420,7 @@ internal static class SdkPackageUpdater
                     continue;
                 }
 
-                // update all dependencies
+                // update all versions
                 foreach (Dependency resolvedDependency in resolvedDependencies
                                                           .Where(d => !d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase))
                                                           .Where(d => d.Version is not null))
@@ -376,7 +436,7 @@ internal static class SdkPackageUpdater
         string dependencyName,
         string? previousDependencyVersion,
         string newDependencyVersion,
-        Logger logger)
+        ILogger logger)
     {
         var foundCorrect = false;
         var foundUnsupported = false;
@@ -619,7 +679,7 @@ internal static class SdkPackageUpdater
                 StringComparison.OrdinalIgnoreCase) &&
             (e.GetAttributeOrSubElementValue("Version", StringComparison.OrdinalIgnoreCase) ?? e.GetAttributeOrSubElementValue("VersionOverride", StringComparison.OrdinalIgnoreCase)) is not null);
 
-    private static async Task<bool> AreDependenciesCoherentAsync(string repoRootPath, string projectPath, string dependencyName, Logger logger, ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms)
+    private static async Task<bool> AreDependenciesCoherentAsync(string repoRootPath, string projectPath, string dependencyName, ILogger logger, ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms)
     {
         var updatedTopLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
         foreach (var tfm in tfms)
@@ -636,7 +696,7 @@ internal static class SdkPackageUpdater
         return true;
     }
 
-    private static async Task SaveBuildFilesAsync(ImmutableArray<ProjectBuildFile> buildFiles, Logger logger)
+    private static async Task SaveBuildFilesAsync(ImmutableArray<ProjectBuildFile> buildFiles, ILogger logger)
     {
         foreach (var buildFile in buildFiles)
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/PackagesConfigUpdater.cs

@@ -13,6 +13,14 @@ using Console = System.Console;
 
 namespace NuGetUpdater.Core;
 
+/// <summary>
+/// Handles package updates for projects that use packages.config.
+/// </summary>
+/// <remarks>
+/// packages.config can appear in non-SDK-style projects, but not in SDK-style projects.
+/// See: https://learn.microsoft.com/en-us/nuget/reference/packages-config
+///      https://learn.microsoft.com/en-us/nuget/resources/check-project-format
+/// <remarks>
 internal static class PackagesConfigUpdater
 {
     public static async Task UpdateDependencyAsync(
@@ -22,12 +30,11 @@ internal static class PackagesConfigUpdater
         string previousDependencyVersion,
         string newDependencyVersion,
         string packagesConfigPath,
-        Logger logger
+        ILogger logger
     )
     {
-        logger.Log($"  Found {NuGetHelper.PackagesConfigFileName}; running with NuGet.exe");
-
-        // use NuGet.exe to perform update
+        // packages.config project; use NuGet.exe to perform update
+        logger.Log($"  Found '{NuGetHelper.PackagesConfigFileName}' project; running NuGet.exe update");
 
         // ensure local packages directory exists
         var projectBuildFile = ProjectBuildFile.Open(repoRootPath, projectPath);
@@ -92,7 +99,7 @@ internal static class PackagesConfigUpdater
         await projectBuildFile.SaveAsync();
     }
 
-    private static void RunNugetUpdate(List<string> updateArgs, List<string> restoreArgs, string projectDirectory, Logger logger)
+    private static void RunNugetUpdate(List<string> updateArgs, List<string> restoreArgs, string projectDirectory, ILogger logger)
     {
         var outputBuilder = new StringBuilder();
         var writer = new StringWriter(outputBuilder);
@@ -126,10 +133,10 @@ internal static class PackagesConfigUpdater
                 //    and doesn't appear in the cache.  The message in this case will be "Could not install package
                 //    '<name> <version>'...the package does not contain any assembly references or content files that
                 //    are compatible with that framework.".
+                // 3. Yet another possibility is that the project explicitly imports a targets file without a condition
+                //    of `Exists(...)`.
                 // The solution in all cases is to run `restore` then try the update again.
-                if (!retryingAfterRestore &&
-                    (fullOutput.Contains("Existing packages must be restored before performing an install or update.") ||
-                    fullOutput.Contains("the package does not contain any assembly references or content files that are compatible with that framework.")))
+                if (!retryingAfterRestore && OutputIndicatesRestoreIsRequired(fullOutput))
                 {
                     retryingAfterRestore = true;
                     logger.Log($"    Running NuGet.exe with args: {string.Join(" ", restoreArgs)}");
@@ -139,6 +146,8 @@ internal static class PackagesConfigUpdater
 
                     if (exitCodeAgain != 0)
                     {
+                        MSBuildHelper.ThrowOnMissingFile(fullOutput);
+                        MSBuildHelper.ThrowOnMissingFile(restoreOutput);
                         MSBuildHelper.ThrowOnMissingPackages(restoreOutput);
                         throw new Exception($"Unable to restore.\nOutput:\n${restoreOutput}\n");
                     }
@@ -174,6 +183,13 @@ internal static class PackagesConfigUpdater
         }
     }
 
+    private static bool OutputIndicatesRestoreIsRequired(string output)
+    {
+        return output.Contains("Existing packages must be restored before performing an install or update.")
+            || output.Contains("the package does not contain any assembly references or content files that are compatible with that framework.")
+            || MSBuildHelper.GetMissingFile(output) is not null;
+    }
+
     private static Process[] GetLikelyNuGetSpawnedProcesses()
     {
         var processes = Process.GetProcesses().Where(p => p.ProcessName.StartsWith("CredentialProvider", StringComparison.OrdinalIgnoreCase) == true).ToArray();
@@ -206,7 +222,7 @@ internal static class PackagesConfigUpdater
             {
                 // exact match was found, use it
                 var subpath = GetUpToIndexWithoutTrailingDirectorySeparator(hintPath, hintPathSubStringLocation);
-                return subpath;
+                return subpath.NormalizePathToUnix();
             }
 
             if (partialPathMatch is null)
@@ -244,7 +260,7 @@ internal static class PackagesConfigUpdater
             }
         }
 
-        return partialPathMatch;
+        return partialPathMatch?.NormalizePathToUnix();
     }
 
     private static bool IsHintPathNodeForDependency(this IXmlElementSyntax element, string dependencyName)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/UpdaterWorker.cs

@@ -9,7 +9,7 @@ namespace NuGetUpdater.Core;
 
 public class UpdaterWorker
 {
-    private readonly Logger _logger;
+    private readonly ILogger _logger;
     private readonly HashSet<string> _processedProjectPaths = new(StringComparer.OrdinalIgnoreCase);
 
     internal static readonly JsonSerializerOptions SerializerOptions = new()
@@ -18,7 +18,7 @@ public class UpdaterWorker
         Converters = { new JsonStringEnumConverter() },
     };
 
-    public UpdaterWorker(Logger logger)
+    public UpdaterWorker(ILogger logger)
     {
         _logger = logger;
     }
@@ -70,6 +70,14 @@ public class UpdaterWorker
                 ErrorDetails = ex.Dependencies,
             };
         }
+        catch (Exception ex)
+        {
+            result = new()
+            {
+                ErrorType = ErrorType.Unknown,
+                ErrorDetails = ex.ToString(),
+            };
+        }
 
         return result;
     }
@@ -114,7 +122,7 @@ public class UpdaterWorker
         return new UpdateOperationResult();
     }
 
-    internal static async Task WriteResultFile(UpdateOperationResult result, string resultOutputPath, Logger logger)
+    internal static async Task WriteResultFile(UpdateOperationResult result, string resultOutputPath, ILogger logger)
     {
         logger.Log($"  Writing update result to [{resultOutputPath}].");
 
@@ -213,7 +221,7 @@ public class UpdaterWorker
         }
 
         // Some repos use a mix of packages.config and PackageReference
-        await SdkPackageUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _logger);
+        await PackageReferenceUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _logger);
 
         // Update lock file if exists
         if (File.Exists(Path.Combine(Path.GetDirectoryName(projectPath), "packages.lock.json")))

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

@@ -0,0 +1,9 @@
+namespace NuGetUpdater.Core;
+
+public sealed class ConsoleLogger : ILogger
+{
+    public void Log(string message)
+    {
+        Console.WriteLine(message);
+    }
+}

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

@@ -55,7 +55,7 @@ public class PackageManager
         string CurrentDirectory = currentDirectory ?? Environment.CurrentDirectory;
         SourceCacheContext SourceCacheContext = new SourceCacheContext();
         PackageDownloadContext PackageDownloadContext = new PackageDownloadContext(SourceCacheContext);
-        ILogger Logger = NullLogger.Instance;
+        var Logger = NullLogger.Instance;
 
         IMachineWideSettings MachineWideSettings = new NuGet.CommandLine.CommandLineMachineWideSettings();
         ISettings Settings = NuGet.Configuration.Settings.LoadDefaultSettings(
@@ -328,7 +328,7 @@ public class PackageManager
     }
 
     // Method to update the version of a desired package based off framework
-    public async Task<string> UpdateVersion(List<PackageToUpdate> existingPackages, PackageToUpdate package, string targetFramework, string projectDirectory)
+    public async Task<string> UpdateVersion(List<PackageToUpdate> existingPackages, PackageToUpdate package, string targetFramework, string projectDirectory, ILogger logger)
     {
         // Bool to track if the package was in the original existing list
         bool inExisting = true;
@@ -392,12 +392,12 @@ public class PackageManager
                                     existingPackage.CurrentVersion = dependency.CurrentVersion;
 
                                     // If the family is compatible with the dependency's version, update with the dependency version
-                                    if (await AreAllParentsCompatibleAsync(existingPackages, existingPackage, targetFramework, projectDirectory) == true)
+                                    if (await AreAllParentsCompatibleAsync(existingPackages, existingPackage, targetFramework, projectDirectory, logger) == true)
                                     {
                                         existingPackage.CurrentVersion = dependencyOldVersion;
                                         string NewVersion = dependency.CurrentVersion;
                                         existingPackage.NewVersion = dependency.CurrentVersion;
-                                        await UpdateVersion(existingPackages, existingPackage, targetFramework, projectDirectory);
+                                        await UpdateVersion(existingPackages, existingPackage, targetFramework, projectDirectory, logger);
                                     }
                                     // If not, resort to putting version back to normal and remove new version
                                     else
@@ -417,7 +417,7 @@ public class PackageManager
                             dependency.IsSpecific = true;
                         }
 
-                        await UpdateVersion(existingPackages, dependency, targetFramework, projectDirectory);
+                        await UpdateVersion(existingPackages, dependency, targetFramework, projectDirectory, logger);
                     }
                 }
 
@@ -432,7 +432,7 @@ public class PackageManager
                     if (!isCompatible)
                     {
                         // Attempt to find and update to a compatible version between the two
-                        NuGetVersion compatibleVersion = await FindCompatibleVersionAsync(existingPackages, parent, package, targetFramework);
+                        NuGetVersion compatibleVersion = await FindCompatibleVersionAsync(existingPackages, parent, package, targetFramework, logger);
                         if (compatibleVersion == null)
                         {
                             return "Failed to update";
@@ -440,7 +440,7 @@ public class PackageManager
 
                         // If a version is found, update to that version
                         parent.NewVersion = compatibleVersion.ToString();
-                        await UpdateVersion(existingPackages, parent, targetFramework, projectDirectory);
+                        await UpdateVersion(existingPackages, parent, targetFramework, projectDirectory, logger);
                     }
 
                     // If it's compatible and the package you updated wasn't in the existing package, check if the parent's dependencies version is the same as the current version
@@ -455,7 +455,6 @@ public class PackageManager
                         {
                             // Create a NugetContext instance to get the latest versions of the parent
                             NuGetContext nugetContext = new NuGetContext(Path.GetDirectoryName(projectPath));
-                            Logger logger = null;
 
                             string currentVersionString = parent.CurrentVersion;
                             NuGetVersion currentVersionParent = NuGetVersion.Parse(currentVersionString);
@@ -487,7 +486,7 @@ public class PackageManager
                                 {
                                     parent.NewVersion = parentVersion;
                                     parent.CurrentVersion = null;
-                                    await UpdateVersion(existingPackages, parent, targetFramework, projectDirectory);
+                                    await UpdateVersion(existingPackages, parent, targetFramework, projectDirectory, logger);
                                     package.IsSpecific = true;
                                     return "Success";
                                 }
@@ -557,7 +556,7 @@ public class PackageManager
     }
 
     // Method to find a compatible version with the child for the parent to update to
-    public async Task<NuGetVersion> FindCompatibleVersionAsync(List<PackageToUpdate> existingPackages, PackageToUpdate possibleParent, PackageToUpdate possibleDependency, string targetFramework)
+    public async Task<NuGetVersion> FindCompatibleVersionAsync(List<PackageToUpdate> existingPackages, PackageToUpdate possibleParent, PackageToUpdate possibleDependency, string targetFramework, ILogger logger)
     {
         string packageId = possibleParent.PackageName;
         string currentVersionString = possibleParent.CurrentVersion;
@@ -567,7 +566,6 @@ public class PackageManager
 
         // Create a NugetContext instance to get the latest versions of the parent
         NuGetContext nugetContext = new NuGetContext(Path.GetDirectoryName(projectPath));
-        Logger logger = null;
 
         var result = await VersionFinder.GetVersionsAsync(possibleParent.PackageName, CurrentVersion, nugetContext, logger, CancellationToken.None);
         var versions = result.GetVersions();
@@ -618,7 +616,7 @@ public class PackageManager
             if (await IsCompatibleAsync(possibleParent, possibleDependency, targetFramework, nugetContext.CurrentDirectory))
             {
                 // Check if parents are compatible, recursively
-                if (await AreAllParentsCompatibleAsync(existingPackages, possibleParent, targetFramework, nugetContext.CurrentDirectory))
+                if (await AreAllParentsCompatibleAsync(existingPackages, possibleParent, targetFramework, nugetContext.CurrentDirectory, logger))
                 {
                     // If compatible, return the new version
                     if (Regex.IsMatch(possibleParent.NewVersion, @"[a-zA-Z]"))
@@ -635,7 +633,7 @@ public class PackageManager
     }
 
     // Method to determine if all the parents of a given package are compatible with the parent's desired version
-    public async Task<bool> AreAllParentsCompatibleAsync(List<PackageToUpdate> existingPackages, PackageToUpdate possibleParent, string targetFramework, string projectDirectory)
+    public async Task<bool> AreAllParentsCompatibleAsync(List<PackageToUpdate> existingPackages, PackageToUpdate possibleParent, string targetFramework, string projectDirectory, ILogger logger)
     {
         // Get the possibleParent parentPackages
         HashSet<PackageToUpdate> parentPackages = GetParentPackages(possibleParent);
@@ -649,18 +647,18 @@ public class PackageManager
             if (!isCompatible)
             {
                 // Find a compatible version if possible
-                NuGetVersion compatibleVersion = await FindCompatibleVersionAsync(existingPackages, parent, possibleParent, targetFramework);
+                NuGetVersion compatibleVersion = await FindCompatibleVersionAsync(existingPackages, parent, possibleParent, targetFramework, logger);
                 if (compatibleVersion == null)
                 {
                     return false;
                 }
 
                 parent.NewVersion = compatibleVersion.ToString();
-                await UpdateVersion(existingPackages, parent, targetFramework, projectDirectory);
+                await UpdateVersion(existingPackages, parent, targetFramework, projectDirectory, logger);
             }
 
             // Recursively check if all ancestors are compatible
-            if (!await AreAllParentsCompatibleAsync(existingPackages, parent, targetFramework, projectDirectory))
+            if (!await AreAllParentsCompatibleAsync(existingPackages, parent, targetFramework, projectDirectory, logger))
             {
                 return false;
             }

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

@@ -0,0 +1,6 @@
+namespace NuGetUpdater.Core;
+
+public interface ILogger
+{
+    void Log(string message);
+}