temp

Author: 0UserName

cli/nugetswitcher.cli/Program.cs

@@ -7,15 +7,18 @@
 using NuGetSwitcher.Core.Commands;
 using NuGetSwitcher.Core.Commands.Enums;
 
+using NuGetSwitcher.Core.References;
+
 using NuGetSwitcher.Interface.Logger.Enums;
 
 using System.Reflection;
+using System.Threading.Tasks;
 
 namespace NuGetSwitcher.CLI
 {
     internal static class Program
     {
-        public static void Main(string[] args)
+        public static async Task Main(string[] args)
         {
             CliArguments cliArgs = new
             CliArguments
@@ -29,23 +32,23 @@ public static void Main(string[] args)
             CliOptions
             (cliArgs.IncludeProjectFile, cliArgs.ExcludeProjectFile, logger);
 
-            CliSolution solution = new
-            CliSolution
+            CliSolution<ProjectReference> solution = new
+            CliSolution<ProjectReference>
             (cliArgs.AbsolutePath);
 
-            ProjectCommand projectCommand = new ProjectCommand(options, solution, logger);
-            PackageCommand packageCommand = new PackageCommand(options, solution, logger);
+            ProjectCommand<ProjectReference> projectCommand = new ProjectCommand<ProjectReference>(options, solution, logger);
+            PackageCommand<ProjectReference> packageCommand = new PackageCommand<ProjectReference>(options, solution, logger);
 
             switch (cliArgs.Mode)
             {
                 case Mode.VR:
                     logger.LogMessage(Assembly.GetExecutingAssembly().GetName().Version.ToString(), Category.I);
                     break;
                 case Mode.PK:
-                    packageCommand.Switch();
+                    await packageCommand.SwitchAsync();
                     break;
                 case Mode.PR:
-                    projectCommand.Switch();
+                    await projectCommand.SwitchAsync();
                     break;
                 default:
                     logger.LogMessage($"Unable to continue program execution, input arguments: { string.Join(' ', args) }", Category.E);

cli/nugetswitcher.cliservice/Solution/CliSolution.cs

@@ -2,9 +2,11 @@
 
 using NuGetSwitcher.Core.Solution.Abstract;
 
+using NuGetSwitcher.Interface.References;
+
 namespace NuGetSwitcher.CLIService.Solution
 {
-    public sealed class CliSolution(string absolutePath) : AbstractSolution(absolutePath)
+    public sealed class CliSolution<TReference>(string absolutePath) : AbstractSolution<TReference> (absolutePath) where TReference : class, IProjectReference 
     {
         /// <inheritdoc cref="ProjectCollection"/>
         private readonly

lib/nugetswitcher.core/Commands/AbstractCommand.cs

@@ -2,94 +2,37 @@
 using CliWrap.Buffered;
 using CliWrap.Builders;
 
-using NuGet.ProjectModel;
-
 using NuGetSwitcher.Interface.Logger;
 using NuGetSwitcher.Interface.Logger.Enums;
 
-using NuGetSwitcher.Interface.Options;
-using NuGetSwitcher.Interface.References;
-
-using System;
-using System.Collections.Generic;
-
 using System.IO;
-using System.Linq;
+using System.Threading.Tasks;
 
 namespace NuGetSwitcher.Core.Commands
 {
-    public abstract class AbstractCommand(string referenceType, IOptions option, ILogger logger)
+    public abstract class AbstractCommand(ILogger logger)
     {
-        public abstract void Switch();
-
-        /// <summary>
-        /// Iterates through the dependencies provided in the lock file and matches 
-        /// against items found in the directories listed in the configuration file. 
-        /// For each matched item, the passed delegate is executed.
-        /// </summary>
-        protected virtual void IterateAndExecute<TReference>(IEnumerable<TReference> references, Action<IProjectReference, LockFileTargetLibrary, string> func) where TReference : IProjectReference
+        protected ILogger Logger
         {
-            logger.Clear();
-
-            IReadOnlyDictionary<string, string> items = option.GetIncludeItems(referenceType);
-
-            foreach (IProjectReference reference in references)
-            {
-                foreach (LockFileTargetLibrary library in reference.GetLockFileLibraries())
-                {
-                    if (items.TryGetValue(library.Name, out string absolutePath))
-                    {
-                        func(reference, library, absolutePath);
-                    }
-                }
-
-                reference.Save();
-            }
+            get => logger;
         }
-
-        /// <summary>
-        /// Adds reference to the project. It is assumed
-        /// that the original reference has been removed 
-        /// earlier.
-        /// </summary>
-        /// 
-        /// <param name="unevaluatedInclude">
-        /// Must contain the assembly 
-        /// name or the absolute path 
-        /// to the project or Package
-        /// Id.
-        /// </param>
-        protected virtual void AddReference(IProjectReference reference, string referenceType, string unevaluatedInclude, Dictionary<string, string> metadata)
-        {
-            if (reference.TryAddReference(unevaluatedInclude, referenceType, metadata))
-            {
-                logger.LogMessage($"{referenceType}: {Path.GetFileName(unevaluatedInclude)} has been added", Category.I, project: reference.Project.FullPath);
-            }
-        }
-
+        
+        public abstract  ValueTask SwitchAsync();
+        
         /// <summary>
         /// Performs an action on the solution file, taking 
         /// into account the passed <paramref name="builder"/>.
         /// </summary>
-        protected virtual void SlnAction(string solution, IEnumerable<string> projects, ArgumentsBuilder builder)
+        /// 
+        /// <param name="absolutePath">
+        /// Absolute path to the solution file.
+        /// </param>
+        protected async Task SlnActionAsync(string absolutePath, ArgumentsBuilder builder)
         {
-            void Log(string source, Category category)
-            {
-                if (!string.IsNullOrWhiteSpace(source))
-                {
-                    logger.Clear();
-                    logger.LogMessage(source, category);
-                }
-            }
-
-            if (projects.Any())
-            {
-                // TODO: Switch to async.
-                BufferedCommandResult result = Cli.Wrap("dotnet").WithWorkingDirectory(Path.GetDirectoryName(solution)).WithArguments(args => args.Add("sln").Add(solution).Add(builder.Build(), false)).ExecuteBufferedAsync().GetAwaiter().GetResult();
-
-                Log(result.StandardOutput, Category.I);
-                Log(result.StandardError, Category.E);
-            }
+            // TODO: Switch to async.
+            BufferedCommandResult result = await Cli.Wrap("dotnet").WithWorkingDirectory(Path.GetDirectoryName(absolutePath)).WithArguments(args => args.Add("sln").Add(absolutePath).Add(builder.Build(), false)).ExecuteBufferedAsync();
+           
+            logger.LogMessage(result.StandardError ?? result.StandardOutput, result.IsSuccess ? Category.I : Category.E);
         }
     }
 }

lib/nugetswitcher.core/Commands/PackageCommand.cs

@@ -2,8 +2,8 @@
 
 using Microsoft.Build.Evaluation;
 
-using NuGetSwitcher.Core.Constants;
-using NuGetSwitcher.Core.References;
+using NuGetSwitcher.Core.Constants; 
+
 using NuGetSwitcher.Interface.Logger;
 using NuGetSwitcher.Interface.Logger.Enums;
 
@@ -13,26 +13,18 @@
 
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
+using System.Threading.Tasks;
 
 namespace NuGetSwitcher.Core.Commands
 {
-    public sealed class PackageCommand(IOptions option, ISolution solution, ILogger logger) : AbstractCommand(ReferenceType.PackageReference, option, logger)
+    public sealed class PackageCommand<TReference>(IOptions option, ISolution<TReference> solution, ILogger logger) : AbstractCommand(logger)where TReference: class, IProjectReference
     {
-        /// <summary>
-        /// Returns references that match the passed type and are marked with the Temp attribute.
-        /// </summary>
-        private static IEnumerable<ProjectItem> GetTempItems(IProjectReference reference, string referenceType)
-        {
-            return reference.Project.GetItems(referenceType).Where(i => i.HasMetadata("Temp")).ToList();
-        }
-
         /// <summary>
         /// Removes projects from the solution file.
         /// </summary>
-        private void RemoveFromSolution(string absolutePath, IEnumerable<string> projects)
+        private async ValueTask RemoveFromSolutionAsync(string absolutePath, IEnumerable<string> projects)
         {
-            SlnAction(absolutePath, projects, new ArgumentsBuilder().Add("remove").Add(projects));
+            await SlnActionAsync(absolutePath, new ArgumentsBuilder().Add("remove").Add(projects));
         }
 
         /// <summary>
@@ -41,13 +33,13 @@ private void RemoveFromSolution(string absolutePath, IEnumerable<string> project
         /// the Dependencies or FrameworkAssemblies sections of the 
         /// lock file.
         /// </summary>
-        public IEnumerable<string> SwitchDependencies(IProjectReference reference, string referenceType)
+        private IEnumerable<string> SwitchDependencies(IProjectReference reference, string referenceType)
         {
             List<string> projects = new
             List<string>
             ();
 
-            foreach (ProjectItem item in GetTempItems(reference, referenceType))
+            foreach (ProjectItem item in reference.GetItems(referenceType, "Temp"))
             {
                 if (referenceType == ReferenceType.ProjectReference)
                 {
@@ -70,28 +62,31 @@ public IEnumerable<string> SwitchDependencies(IProjectReference reference, strin
                     item.ItemType = referenceType;
                 }
 
-                logger.LogMessage($"{referenceType}: {Path.GetFileName(item.EvaluatedInclude)} has been switched back", Category.I, project: reference.Project.FullPath);
+                Logger.LogMessage($"{referenceType}: {Path.GetFileName(item.EvaluatedInclude)} has been switched back", Category.I, project: reference.Project.FullPath);
             }
 
             return projects;
         }
 
         /// <inheritdoc/>
-        public override void Switch()
+        public override async ValueTask SwitchAsync()
         {
             HashSet<string> projects = new
             HashSet<string>
             ();
 
-            foreach (IProjectReference reference in solution.GetLoadedProjects<ProjectReference>())
+            foreach (TReference reference in await solution.GetLoadedProjectsAsync())
             {
-                projects.UnionWith(SwitchDependencies(reference, ReferenceType.Reference));
+                SwitchDependencies(reference, ReferenceType.Reference);
                 projects.UnionWith(SwitchDependencies(reference, ReferenceType.ProjectReference));
 
                 reference.Save();
             }
 
-            RemoveFromSolution(solution.AbsolutePath, projects);
+            if (projects.Count != default)
+            {
+                await RemoveFromSolutionAsync(solution.AbsolutePath, projects);
+            }
         }
     }
 }