Refactor SlnFileFactory + slnf (#46002)

edvilme · web-flow · commit e1caf34b9591 · 2025-01-21T09:12:02.000-08:00
diff --git a/src/Cli/dotnet/ReleasePropertyProjectLocator.cs b/src/Cli/dotnet/ReleasePropertyProjectLocator.cs
@@ -155,7 +155,7 @@ public IEnumerable<string> GetCustomDefaultConfigurationValueIfSpecified()
             SolutionModel sln;
             try
             {
-                sln = SlnFileFactory.CreateFromFileOrDirectory(slnFullPath, false);
+                sln = SlnFileFactory.CreateFromFileOrDirectory(slnFullPath, false, false);
             }
             catch (GracefulException)
             {
diff --git a/src/Cli/dotnet/SlnFileFactory.cs b/src/Cli/dotnet/SlnFileFactory.cs
@@ -1,6 +1,7 @@
 ﻿// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Text.Json;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.VisualStudio.SolutionPersistence;
 using Microsoft.VisualStudio.SolutionPersistence.Model;
@@ -10,6 +11,40 @@ namespace Microsoft.DotNet.Tools.Common
 {
     public static class SlnFileFactory
     {
+        public static string GetSolutionFileFullPath(string slnFileOrDirectory, bool includeSolutionFilterFiles = false, bool includeSolutionXmlFiles = true)
+        {
+            // Throw error if slnFileOrDirectory is an invalid path
+            if (string.IsNullOrWhiteSpace(slnFileOrDirectory) || slnFileOrDirectory.IndexOfAny(Path.GetInvalidPathChars()) != -1)
+            {
+                throw new GracefulException(CommonLocalizableStrings.CouldNotFindSolutionOrDirectory);
+            }
+            if (File.Exists(slnFileOrDirectory))
+            {
+                return Path.GetFullPath(slnFileOrDirectory);
+            }
+            if (Directory.Exists(slnFileOrDirectory))
+            {
+                string[] files = ListSolutionFilesInDirectory(slnFileOrDirectory, includeSolutionFilterFiles, includeSolutionXmlFiles);
+                if (files.Length == 0)
+                {
+                    throw new GracefulException(
+                        CommonLocalizableStrings.CouldNotFindSolutionIn,
+                        slnFileOrDirectory);
+                }
+                if (files.Length > 1)
+                {
+                    throw new GracefulException(
+                        CommonLocalizableStrings.MoreThanOneSolutionInDirectory,
+                        slnFileOrDirectory);
+                }
+                return Path.GetFullPath(files.Single());
+            }
+            throw new GracefulException(
+                CommonLocalizableStrings.CouldNotFindSolutionOrDirectory,
+                slnFileOrDirectory);
+        }
+
+
         public static string[] ListSolutionFilesInDirectory(string directory, bool includeSolutionFilterFiles = false, bool includeSolutionXmlFiles = true)
         {
             return [
@@ -19,87 +54,77 @@ public static string[] ListSolutionFilesInDirectory(string directory, bool inclu
             ];
         }
 
-        public static SolutionModel CreateFromFileOrDirectory(string fileOrDirectory, bool includeSolutionXmlFiles = true)
+        public static SolutionModel CreateFromFileOrDirectory(string fileOrDirectory, bool includeSolutionFilterFiles = false, bool includeSolutionXmlFiles = true)
         {
-            if (File.Exists(fileOrDirectory))
-            {
-                return FromFile(fileOrDirectory);
-            }
-            else
-            {
-                return FromDirectory(fileOrDirectory, includeSolutionXmlFiles);
-            }
-        }
+            string solutionPath = GetSolutionFileFullPath(fileOrDirectory, includeSolutionFilterFiles, includeSolutionXmlFiles);
 
-        private static SolutionModel FromFile(string solutionPath)
-        {
-            SolutionModel slnFile = null;
-            try
+            if (solutionPath.HasExtension(".slnf"))
             {
-                ISolutionSerializer serializer = SolutionSerializers.GetSerializerByMoniker(solutionPath) ?? throw new GracefulException(
+                return CreateFromFilteredSolutionFile(solutionPath);
+            }
+            ISolutionSerializer serializer = SolutionSerializers.GetSerializerByMoniker(solutionPath) ?? throw new GracefulException(
                     CommonLocalizableStrings.CouldNotFindSolutionOrDirectory,
                     solutionPath);
 
-                slnFile = serializer.OpenAsync(solutionPath, CancellationToken.None).Result;
-            }
-            catch (SolutionException e)
-            {
-                throw new GracefulException(
-                    CommonLocalizableStrings.InvalidSolutionFormatString,
-                    solutionPath,
-                    e.Message);
-            }
-            return slnFile;
+            return serializer.OpenAsync(solutionPath, CancellationToken.None).Result;
         }
 
-        private static SolutionModel FromDirectory(string solutionDirectory, bool includeSolutionXmlFiles)
+        public static SolutionModel CreateFromFilteredSolutionFile(string filteredSolutionPath)
         {
-            DirectoryInfo dir;
+            JsonDocument jsonDocument;
+            JsonElement jsonElement;
+            JsonElement filteredSolutionJsonElement;
+            string originalSolutionPath;
+            string originalSolutionPathAbsolute;
+            string[] filteredSolutionProjectPaths;
+
             try
             {
-                dir = new DirectoryInfo(solutionDirectory);
-                if (!dir.Exists)
+                jsonDocument = JsonDocument.Parse(File.ReadAllText(filteredSolutionPath));
+                jsonElement = jsonDocument.RootElement;
+                filteredSolutionJsonElement = jsonElement.GetProperty("solution");
+                originalSolutionPath = filteredSolutionJsonElement.GetProperty("path").GetString();
+                originalSolutionPathAbsolute = Path.GetFullPath(originalSolutionPath, Path.GetDirectoryName(filteredSolutionPath));
+                if (!File.Exists(originalSolutionPathAbsolute))
                 {
-                    throw new GracefulException(
-                        CommonLocalizableStrings.CouldNotFindSolutionOrDirectory,
-                        solutionDirectory);
+                    throw new Exception();
                 }
+                filteredSolutionProjectPaths = filteredSolutionJsonElement.GetProperty("projects")
+                    .EnumerateArray()
+                    .Select(project => project.GetString())
+                    .ToArray();
             }
-            catch (ArgumentException)
-            {
+            catch (Exception ex) {
                 throw new GracefulException(
-                    CommonLocalizableStrings.CouldNotFindSolutionOrDirectory,
-                    solutionDirectory);
+                    CommonLocalizableStrings.InvalidSolutionFormatString,
+                    filteredSolutionPath, ex.Message);
             }
 
-            FileInfo[] files = [
-                ..dir.GetFiles("*.sln"),
-                ..(includeSolutionXmlFiles ? dir.GetFiles(".slnx") : [])
-             ];
+            SolutionModel filteredSolution = new SolutionModel();
+            SolutionModel originalSolution = CreateFromFileOrDirectory(originalSolutionPathAbsolute);
 
-            if (files.Length == 0)
+            foreach (var platform in originalSolution.Platforms)
             {
-                throw new GracefulException(
-                    CommonLocalizableStrings.CouldNotFindSolutionIn,
-                    solutionDirectory);
+                filteredSolution.AddPlatform(platform);
             }
-
-            if (files.Length > 1)
+            foreach (var buildType in originalSolution.BuildTypes)
             {
-                throw new GracefulException(
-                    CommonLocalizableStrings.MoreThanOneSolutionInDirectory,
-                    solutionDirectory);
+                filteredSolution.AddBuildType(buildType);
             }
 
-            FileInfo solutionFile = files.Single();
-            if (!solutionFile.Exists)
+            foreach (string path in filteredSolutionProjectPaths)
             {
-                throw new GracefulException(
-                    CommonLocalizableStrings.CouldNotFindSolutionIn,
-                    solutionDirectory);
+                // Normalize path to use correct directory separator
+                string normalizedPath = path.Replace('\\', Path.DirectorySeparatorChar);
+
+                SolutionProjectModel project = originalSolution.FindProject(normalizedPath) ?? throw new GracefulException(
+                        CommonLocalizableStrings.ProjectNotFoundInTheSolution,
+                        normalizedPath,
+                        originalSolutionPath);
+                filteredSolution.AddProject(project.FilePath, project.Type, project.Parent is null ? null : filteredSolution.AddFolder(project.Parent.Path));
             }
 
-            return FromFile(solutionFile.FullName);
+            return filteredSolution;
         }
     }
 }
diff --git a/src/Cli/dotnet/commands/dotnet-sln/SlnCommandParser.cs b/src/Cli/dotnet/commands/dotnet-sln/SlnCommandParser.cs
@@ -47,39 +47,6 @@ private static CliCommand ConstructCommand()
 
             return command;
         }
-
-        internal static string GetSlnFileFullPath(string slnFileOrDirectory)
-        {
-            if (File.Exists(slnFileOrDirectory))
-            {
-                return Path.GetFullPath(slnFileOrDirectory);
-            }
-            if (Directory.Exists(slnFileOrDirectory))
-            {
-                string[] files = [
-                    ..Directory.GetFiles(slnFileOrDirectory, "*.sln", SearchOption.TopDirectoryOnly),
-                    ..Directory.GetFiles(slnFileOrDirectory, "*.slnx", SearchOption.TopDirectoryOnly)];
-                if (files.Length == 0)
-                {
-                    throw new GracefulException(CommonLocalizableStrings.CouldNotFindSolutionIn, slnFileOrDirectory);
-                }
-                if (files.Length > 1)
-                {
-                    throw new GracefulException(CommonLocalizableStrings.MoreThanOneSolutionInDirectory, slnFileOrDirectory);
-                }
-                return Path.GetFullPath(files.Single());
-            }
-            throw new GracefulException(CommonLocalizableStrings.CouldNotFindSolutionOrDirectory, slnFileOrDirectory);
-        }
-
-        internal static ISolutionSerializer GetSolutionSerializer(string solutionFilePath)
-        {
-            ISolutionSerializer? serializer = SolutionSerializers.GetSerializerByMoniker(solutionFilePath);
-            if (serializer is null)
-            {
-                throw new GracefulException(LocalizableStrings.SerializerNotFound, solutionFilePath);
-            }
-            return serializer;
-        }
     }
+
 }
diff --git a/src/Cli/dotnet/commands/dotnet-sln/add/Program.cs b/src/Cli/dotnet/commands/dotnet-sln/add/Program.cs
@@ -46,7 +46,7 @@ public override int Execute()
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToAdd);
             }
-            string solutionFileFullPath = SlnCommandParser.GetSlnFileFullPath(_fileOrDirectory);
+            string solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory);
 
             try
             {
@@ -73,8 +73,8 @@ public override int Execute()
 
         private async Task AddProjectsToSolutionAsync(string solutionFileFullPath, IEnumerable<string> projectPaths, CancellationToken cancellationToken)
         {
-            ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(solutionFileFullPath);
-            SolutionModel solution = await serializer.OpenAsync(solutionFileFullPath, cancellationToken);
+            SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(solutionFileFullPath);
+            ISolutionSerializer serializer = solution.SerializerExtension.Serializer;
             // set UTF8 BOM encoding for .sln
             if (serializer is ISolutionSerializer<SlnV12SerializerSettings> v12Serializer)
             {
diff --git a/src/Cli/dotnet/commands/dotnet-sln/list/Program.cs b/src/Cli/dotnet/commands/dotnet-sln/list/Program.cs
@@ -4,6 +4,7 @@
 using System.CommandLine;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Tools.Common;
 using Microsoft.VisualStudio.SolutionPersistence;
 using Microsoft.VisualStudio.SolutionPersistence.Model;
 using CommandLocalizableStrings = Microsoft.DotNet.Tools.CommonLocalizableStrings;
@@ -24,10 +25,10 @@ public ListProjectsInSolutionCommand(
 
         public override int Execute()
         {
-            string solutionFileFullPath = SlnCommandParser.GetSlnFileFullPath(_fileOrDirectory);
+            string solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory, includeSolutionFilterFiles: true);
             try
             {
-                ListAllProjectsAsync(solutionFileFullPath, CancellationToken.None).Wait();
+                ListAllProjectsAsync(solutionFileFullPath);
                 return 0;
             }
             catch (Exception ex)
@@ -36,10 +37,9 @@ public override int Execute()
             }
         }
 
-        private async Task ListAllProjectsAsync(string solutionFileFullPath, CancellationToken cancellationToken)
+        private void ListAllProjectsAsync(string solutionFileFullPath)
         {
-            ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(solutionFileFullPath);
-            SolutionModel solution = await serializer.OpenAsync(solutionFileFullPath, cancellationToken);
+            SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(solutionFileFullPath);
             string[] paths;
             if (_displaySolutionFolders)
             {
diff --git a/src/Cli/dotnet/commands/dotnet-sln/migrate/SlnMigrateCommand.cs b/src/Cli/dotnet/commands/dotnet-sln/migrate/SlnMigrateCommand.cs
@@ -33,7 +33,7 @@ public SlnMigrateCommand(
 
         public override int Execute()
         {
-            string slnFileFullPath = SlnCommandParser.GetSlnFileFullPath(_slnFileOrDirectory);
+            string slnFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_slnFileOrDirectory);
             if (slnFileFullPath.HasExtension(".slnx"))
             {
                 throw new GracefulException(LocalizableStrings.CannotMigrateSlnx);
@@ -50,8 +50,7 @@ public override int Execute()
 
         private async Task ConvertToSlnxAsync(string filePath, string slnxFilePath, CancellationToken cancellationToken)
         {
-            ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(filePath);
-            SolutionModel solution = await serializer.OpenAsync(filePath, cancellationToken);
+            SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(filePath);
             await SolutionSerializers.SlnXml.SaveAsync(slnxFilePath, solution, cancellationToken);
             _reporter.WriteLine(LocalizableStrings.SlnxGenerated, slnxFilePath);
         }
diff --git a/src/Cli/dotnet/commands/dotnet-sln/remove/Program.cs b/src/Cli/dotnet/commands/dotnet-sln/remove/Program.cs
@@ -30,7 +30,7 @@ public RemoveProjectFromSolutionCommand(ParseResult parseResult) : base(parseRes
 
         public override int Execute()
         {
-            string solutionFileFullPath = SlnCommandParser.GetSlnFileFullPath(_fileOrDirectory);
+            string solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory);
             if (_projects.Count == 0)
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToRemove);
@@ -47,7 +47,7 @@ public override int Execute()
                             ? MsbuildProject.GetProjectFileFromDirectory(fullPath).FullName
                             : fullPath);
                 });
-                RemoveProjectsAsync(solutionFileFullPath, relativeProjectPaths, CancellationToken.None).Wait();
+                RemoveProjectsAsync(solutionFileFullPath, relativeProjectPaths, CancellationToken.None).GetAwaiter().GetResult();
                 return 0;
             }
             catch (Exception ex) when (ex is not GracefulException)
@@ -56,18 +56,14 @@ public override int Execute()
                 {
                     throw new GracefulException(CommonLocalizableStrings.InvalidSolutionFormatString, solutionFileFullPath, ex.Message);
                 }
-                if (ex.InnerException is GracefulException)
-                {
-                    throw ex.InnerException;
-                }
                 throw new GracefulException(ex.Message, ex);
             }
         }
 
         private async Task RemoveProjectsAsync(string solutionFileFullPath, IEnumerable<string> projectPaths, CancellationToken cancellationToken)
         {
-            ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(solutionFileFullPath);
-            SolutionModel solution = await serializer.OpenAsync(solutionFileFullPath, cancellationToken);
+            SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(solutionFileFullPath);
+            ISolutionSerializer serializer = solution.SerializerExtension.Serializer;
 
             // set UTF-8 BOM encoding for .sln
             if (serializer is ISolutionSerializer<SlnV12SerializerSettings> v12Serializer)
diff --git a/test/TestAssets/TestProjects/TestAppWithSlnxAndSolutionFilters/App.slnf b/test/TestAssets/TestProjects/TestAppWithSlnxAndSolutionFilters/App.slnf
@@ -0,0 +1,8 @@
+{
+    "solution": {
+        "path": "./App.slnx", 
+        "projects": [
+            "src\\App\\App.csproj"
+        ]
+    }
+}
diff --git a/test/TestAssets/TestProjects/TestAppWithSlnxAndSolutionFilters/App.slnx b/test/TestAssets/TestProjects/TestAppWithSlnxAndSolutionFilters/App.slnx
@@ -0,0 +1,4 @@
+<Solution>
+  <Project Path="src/App/App.csproj" />
+  <Project Path="src/OtherApp/OtherApp.csproj" />
+</Solution>
diff --git a/test/dotnet-sln.Tests/GivenDotnetSlnList.cs b/test/dotnet-sln.Tests/GivenDotnetSlnList.cs
@@ -260,5 +260,25 @@ public void WhenProjectsInSolutionFoldersPresentInTheSolutionItListsSolutionFold
             cmd.Should().Pass();
             cmd.StdOut.Should().ContainAll(expectedOutput);
         }
+
+        [Theory]
+        [InlineData("sln")]
+        [InlineData("solution")]
+        public void WhenSolutionFilterIsPassedItListsProjectsMatching(string solutionCommand)
+        {
+            string[] expectedOutput = { $"{CommandLocalizableStrings.ProjectsHeader}",
+                $"{new string('-', CommandLocalizableStrings.ProjectsHeader.Length)}",
+                $"{Path.Combine("src", "App", "App.csproj")}" };
+            var projectDirectory = _testAssetsManager
+                .CopyTestAsset("TestAppWithSlnxAndSolutionFilters", identifier: "GivenDotnetSlnList-Filter")
+                .WithSource()
+                .Path;
+
+            var cmd = new DotnetCommand(Log)
+                .WithWorkingDirectory(projectDirectory)
+                .Execute(solutionCommand, "App.slnf", "list");
+            cmd.Should().Pass();
+            cmd.StdOut.Should().ContainAll(expectedOutput);
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ public IEnumerable<string> GetCustomDefaultConfigurationValueIfSpecified()`
`155`	`155`	`SolutionModel sln;`
`156`	`156`	`try`
`157`	`157`	`{`
`158`		`- sln = SlnFileFactory.CreateFromFileOrDirectory(slnFullPath, false);`
	`158`	`+ sln = SlnFileFactory.CreateFromFileOrDirectory(slnFullPath, false, false);`
`159`	`159`	`}`
`160`	`160`	`catch (GracefulException)`
`161`	`161`	`{`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public override int Execute()`
`46`	`46`	`{`
`47`	`47`	`throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToAdd);`
`48`	`48`	`}`
`49`		`- string solutionFileFullPath = SlnCommandParser.GetSlnFileFullPath(_fileOrDirectory);`
	`49`	`+ string solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory);`
`50`	`50`
`51`	`51`	`try`
`52`	`52`	`{`
`@@ -73,8 +73,8 @@ public override int Execute()`
`73`	`73`
`74`	`74`	`private async Task AddProjectsToSolutionAsync(string solutionFileFullPath, IEnumerable<string> projectPaths, CancellationToken cancellationToken)`
`75`	`75`	`{`
`76`		`- ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(solutionFileFullPath);`
`77`		`- SolutionModel solution = await serializer.OpenAsync(solutionFileFullPath, cancellationToken);`
	`76`	`+ SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(solutionFileFullPath);`
	`77`	`+ ISolutionSerializer serializer = solution.SerializerExtension.Serializer;`
`78`	`78`	`// set UTF8 BOM encoding for .sln`
`79`	`79`	`if (serializer is ISolutionSerializer<SlnV12SerializerSettings> v12Serializer)`
`80`	`80`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.CommandLine;`
`5`	`5`	`using Microsoft.DotNet.Cli;`
`6`	`6`	`using Microsoft.DotNet.Cli.Utils;`
	`7`	`+using Microsoft.DotNet.Tools.Common;`
`7`	`8`	`using Microsoft.VisualStudio.SolutionPersistence;`
`8`	`9`	`using Microsoft.VisualStudio.SolutionPersistence.Model;`
`9`	`10`	`using CommandLocalizableStrings = Microsoft.DotNet.Tools.CommonLocalizableStrings;`
`@@ -24,10 +25,10 @@ public ListProjectsInSolutionCommand(`
`24`	`25`
`25`	`26`	`public override int Execute()`
`26`	`27`	`{`
`27`		`- string solutionFileFullPath = SlnCommandParser.GetSlnFileFullPath(_fileOrDirectory);`
	`28`	`+ string solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory, includeSolutionFilterFiles: true);`
`28`	`29`	`try`
`29`	`30`	`{`
`30`		`- ListAllProjectsAsync(solutionFileFullPath, CancellationToken.None).Wait();`
	`31`	`+ ListAllProjectsAsync(solutionFileFullPath);`
`31`	`32`	`return 0;`
`32`	`33`	`}`
`33`	`34`	`catch (Exception ex)`
`@@ -36,10 +37,9 @@ public override int Execute()`
`36`	`37`	`}`
`37`	`38`	`}`
`38`	`39`
`39`		`- private async Task ListAllProjectsAsync(string solutionFileFullPath, CancellationToken cancellationToken)`
	`40`	`+ private void ListAllProjectsAsync(string solutionFileFullPath)`
`40`	`41`	`{`
`41`		`- ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(solutionFileFullPath);`
`42`		`- SolutionModel solution = await serializer.OpenAsync(solutionFileFullPath, cancellationToken);`
	`42`	`+ SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(solutionFileFullPath);`
`43`	`43`	`string[] paths;`
`44`	`44`	`if (_displaySolutionFolders)`
`45`	`45`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public SlnMigrateCommand(`
`33`	`33`
`34`	`34`	`public override int Execute()`
`35`	`35`	`{`
`36`		`- string slnFileFullPath = SlnCommandParser.GetSlnFileFullPath(_slnFileOrDirectory);`
	`36`	`+ string slnFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_slnFileOrDirectory);`
`37`	`37`	`if (slnFileFullPath.HasExtension(".slnx"))`
`38`	`38`	`{`
`39`	`39`	`throw new GracefulException(LocalizableStrings.CannotMigrateSlnx);`
`@@ -50,8 +50,7 @@ public override int Execute()`
`50`	`50`
`51`	`51`	`private async Task ConvertToSlnxAsync(string filePath, string slnxFilePath, CancellationToken cancellationToken)`
`52`	`52`	`{`
`53`		`- ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(filePath);`
`54`		`- SolutionModel solution = await serializer.OpenAsync(filePath, cancellationToken);`
	`53`	`+ SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(filePath);`
`55`	`54`	`await SolutionSerializers.SlnXml.SaveAsync(slnxFilePath, solution, cancellationToken);`
`56`	`55`	`_reporter.WriteLine(LocalizableStrings.SlnxGenerated, slnxFilePath);`
`57`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public RemoveProjectFromSolutionCommand(ParseResult parseResult) : base(parseRes`
`30`	`30`
`31`	`31`	`public override int Execute()`
`32`	`32`	`{`
`33`		`- string solutionFileFullPath = SlnCommandParser.GetSlnFileFullPath(_fileOrDirectory);`
	`33`	`+ string solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory);`
`34`	`34`	`if (_projects.Count == 0)`
`35`	`35`	`{`
`36`	`36`	`throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToRemove);`
`@@ -47,7 +47,7 @@ public override int Execute()`
`47`	`47`	`? MsbuildProject.GetProjectFileFromDirectory(fullPath).FullName`
`48`	`48`	`: fullPath);`
`49`	`49`	`});`
`50`		`- RemoveProjectsAsync(solutionFileFullPath, relativeProjectPaths, CancellationToken.None).Wait();`
	`50`	`+ RemoveProjectsAsync(solutionFileFullPath, relativeProjectPaths, CancellationToken.None).GetAwaiter().GetResult();`
`51`	`51`	`return 0;`
`52`	`52`	`}`
`53`	`53`	`catch (Exception ex) when (ex is not GracefulException)`
`@@ -56,18 +56,14 @@ public override int Execute()`
`56`	`56`	`{`
`57`	`57`	`throw new GracefulException(CommonLocalizableStrings.InvalidSolutionFormatString, solutionFileFullPath, ex.Message);`
`58`	`58`	`}`
`59`		`- if (ex.InnerException is GracefulException)`
`60`		`- {`
`61`		`- throw ex.InnerException;`
`62`		`- }`
`63`	`59`	`throw new GracefulException(ex.Message, ex);`
`64`	`60`	`}`
`65`	`61`	`}`
`66`	`62`
`67`	`63`	`private async Task RemoveProjectsAsync(string solutionFileFullPath, IEnumerable<string> projectPaths, CancellationToken cancellationToken)`
`68`	`64`	`{`
`69`		`- ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(solutionFileFullPath);`
`70`		`- SolutionModel solution = await serializer.OpenAsync(solutionFileFullPath, cancellationToken);`
	`65`	`+ SolutionModel solution = SlnFileFactory.CreateFromFileOrDirectory(solutionFileFullPath);`
	`66`	`+ ISolutionSerializer serializer = solution.SerializerExtension.Serializer;`
`71`	`67`
`72`	`68`	`// set UTF-8 BOM encoding for .sln`
`73`	`69`	`if (serializer is ISolutionSerializer<SlnV12SerializerSettings> v12Serializer)`