Use Microsoft.VisualStudio.SolutionPersistence namespace to parse sol…

…ution files
dotnet · mariam-abdulla · Jan 10, 2025 · Jan 3, 2025 · Jan 3, 2025 · Jan 6, 2025
commit cbc3389c48dde8c073290e3f5002bf26d585d7f3
@@ -19,6 +19,7 @@ internal sealed class MSBuildHandler : IDisposable
         private bool _areTestingPlatformApplications = true;
 
         private const string BinLogFileName = "msbuild.binlog";
+        private const string Separator = ";";
         private static readonly object s_buildLock = new();
 
         public MSBuildHandler(List<string> args, TestApplicationActionQueue actionQueue, int degreeOfParallelism)
@@ -28,7 +29,7 @@ public MSBuildHandler(List<string> args, TestApplicationActionQueue actionQueue,
             _degreeOfParallelism = degreeOfParallelism;
         }
 
-        public int RunWithMSBuild(bool allowBinLog)
+        public async Task<int> RunWithMSBuild(bool allowBinLog)
         {
             bool solutionOrProjectFileFound = SolutionAndProjectUtility.TryGetSolutionOrProjectFilePath(Directory.GetCurrentDirectory(), out string filePath, out bool isSolution);
 
@@ -37,16 +38,16 @@ public int RunWithMSBuild(bool allowBinLog)
                 return ExitCodes.GenericFailure;
             }
 
-            (IEnumerable<Module> modules, bool restored) = GetProjectsProperties(filePath, isSolution, allowBinLog);
+            (IEnumerable<Module> modules, bool restored) = await GetProjectsProperties(filePath, isSolution, allowBinLog);
 
             InitializeTestApplications(modules);
 
             return restored ? ExitCodes.Success : ExitCodes.GenericFailure;
         }
 
-        public int RunWithMSBuild(string filePath, bool allowBinLog)
+        public async Task<int> RunWithMSBuild(string filePath, bool allowBinLog)
         {
-            (IEnumerable<Module> modules, bool restored) = GetProjectsProperties(filePath, false, allowBinLog);
+            (IEnumerable<Module> modules, bool restored) = await GetProjectsProperties(filePath, false, allowBinLog);
 
             InitializeTestApplications(modules);
 
@@ -84,14 +85,14 @@ public bool EnqueueTestApplications()
             return true;
         }
 
-        private (IEnumerable<Module>, bool Restored) GetProjectsProperties(string solutionOrProjectFilePath, bool isSolution, bool allowBinLog)
+        private async Task<(IEnumerable<Module>, bool Restored)> GetProjectsProperties(string solutionOrProjectFilePath, bool isSolution, bool allowBinLog)
         {
             var allProjects = new ConcurrentBag<Module>();
             bool restored = true;
 
             if (isSolution)
             {
-                var projects = SolutionAndProjectUtility.GetProjectsFromSolutionFile(solutionOrProjectFilePath);
+                var projects = await SolutionAndProjectUtility.ParseSolution(solutionOrProjectFilePath);
                 ProcessProjectsInParallel(projects, allowBinLog, allProjects, ref restored);
             }
             else
@@ -174,7 +175,7 @@ private static IEnumerable<Module> ExtractModulesFromProject(Project project)
             }
             else
             {
-                var frameworks = targetFrameworks.Split(';', StringSplitOptions.RemoveEmptyEntries);
+                var frameworks = targetFrameworks.Split(Separator, StringSplitOptions.RemoveEmptyEntries);
                 foreach (var framework in frameworks)
                 {
                     project.SetProperty(ProjectProperties.TargetFramework, framework);

@@ -1,8 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.Build.Construction;
 using Microsoft.DotNet.Tools.Test;
+using Microsoft.VisualStudio.SolutionPersistence.Model;
+using Microsoft.VisualStudio.SolutionPersistence.Serializer;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -45,17 +46,47 @@ public static bool TryGetSolutionOrProjectFilePath(string directory, out string
             return false;
         }
 
-        public static IEnumerable<string> GetProjectsFromSolutionFile(string solutionFilePath)
+        public static async Task<IEnumerable<string>> ParseSolution(string solutionFilePath)
         {
-            var solutionFile = SolutionFile.Parse(solutionFilePath);
-            return solutionFile.ProjectsInOrder.Select(project => project.AbsolutePath);
+            if (string.IsNullOrEmpty(solutionFilePath))
+            {
+                VSTestTrace.SafeWriteTrace(() => $"Solution file path cannot be null or empty: {solutionFilePath}");
+                return [];
+            }
+
+            var projectsPaths = new List<string>();
+            SolutionModel solution = null;
+
+            try
+            {
+                using var stream = new FileStream(solutionFilePath, FileMode.Open, FileAccess.Read);
+                string extension = Path.GetExtension(solutionFilePath);
+
+                solution = extension.Equals(".sln", StringComparison.OrdinalIgnoreCase)
+                    ? await SolutionSerializers.SlnFileV12.OpenAsync(stream, CancellationToken.None)
+                    : extension.Equals(".slnx", StringComparison.OrdinalIgnoreCase)
+                        ? await SolutionSerializers.SlnXml.OpenAsync(stream, CancellationToken.None)
+                        : null;
+            }
+            catch (Exception ex)
+            {
+                VSTestTrace.SafeWriteTrace(() => $"Failed to parse solution file '{solutionFilePath}': {ex.Message}");
+                return [];
+            }
+
+            if (solution is not null)
+            {
+                projectsPaths = [.. solution.SolutionProjects.Select(project => project.FilePath)];
+            }
+
+            return projectsPaths;
         }
 
         private static string[] GetSolutionFilePaths(string directory)
         {
-            var solutionFiles = Directory.GetFiles(directory, "*.sln", SearchOption.TopDirectoryOnly)
-                .Concat(Directory.GetFiles(directory, "*.slnx", SearchOption.TopDirectoryOnly))
-                .ToArray();
+            string[] solutionFiles = [
+                    ..Directory.GetFiles(directory, "*.sln", SearchOption.TopDirectoryOnly),
+                    ..Directory.GetFiles(directory, "*.slnx", SearchOption.TopDirectoryOnly)];
 
             return solutionFiles;
         }

@@ -190,7 +190,7 @@ private static CliCommand ConstructCommand()
         private static CliCommand GetTestingPlatformCliCommand()
         {
             var command = new TestingPlatformCommand("test");
-            command.SetAction((parseResult) => command.Run(parseResult));
+            command.SetAction(async (parseResult) => await command.Run(parseResult));
             command.Options.Add(TestingPlatformOptions.MaxParallelTestModulesOption);
             command.Options.Add(TestingPlatformOptions.AdditionalMSBuildParametersOption);
             command.Options.Add(TestingPlatformOptions.TestModulesFilterOption);

@@ -14,11 +14,11 @@ internal partial class TestingPlatformCommand
 
         public IEnumerable<Action<HelpContext>> CustomHelpLayout()
         {
-            yield return (context) =>
+            yield return async (context) =>
             {
                 Console.WriteLine("Waiting for options and extensions...");
 
-                Run(context.ParseResult);
+                await Run(context.ParseResult);
 
                 if (_commandLineOptionNameToModuleNames.IsEmpty)
                 {

@@ -22,7 +22,7 @@ public TestingPlatformCommand(string name, string description = null) : base(nam
             TreatUnmatchedTokensAsErrors = false;
         }
 
-        public int Run(ParseResult parseResult)
+        public async Task<int> Run(ParseResult parseResult)
         {
             bool hasFailed = false;
             try
@@ -90,7 +90,8 @@ public int Run(ParseResult parseResult)
                 else
                 {
                     bool allowBinLog = IsBinLogEnabled(_args);
-                    if (!RunMSBuild(parseResult, allowBinLog))
+
+                    if (!await RunMSBuild(parseResult, allowBinLog))
                     {
                         return ExitCodes.GenericFailure;
                     }
@@ -116,32 +117,32 @@ public int Run(ParseResult parseResult)
             return hasFailed ? ExitCodes.GenericFailure : ExitCodes.Success;
         }
 
-        private bool RunMSBuild(ParseResult parseResult, bool allowBinLog)
+        private async Task<bool> RunMSBuild(ParseResult parseResult, bool allowBinLog)
         {
-            int msbuildResult;
+            int msbuildExitCode;
 
             if (parseResult.HasOption(TestingPlatformOptions.ProjectOption))
             {
                 string filePath = parseResult.GetValue(TestingPlatformOptions.ProjectOption);
 
                 if (!File.Exists(filePath))
                 {
-                    VSTestTrace.SafeWriteTrace(() => LocalizableStrings.CmdNonExistentProjectFilePathDescription);
+                    VSTestTrace.SafeWriteTrace(() => string.Format(LocalizableStrings.CmdNonExistentProjectFilePathDescription, filePath));
                     return false;
                 }
 
-                msbuildResult = _msBuildConnectionHandler.RunWithMSBuild(filePath, allowBinLog);
+                msbuildExitCode = await _msBuildConnectionHandler.RunWithMSBuild(filePath, allowBinLog);
             }
             else
             {
                 // If no filter was provided neither the project using --project,
                 // MSBuild will get the test project paths in the current directory
-                msbuildResult = _msBuildConnectionHandler.RunWithMSBuild(allowBinLog);
+                msbuildExitCode = await _msBuildConnectionHandler.RunWithMSBuild(allowBinLog);
             }
 
-            if (msbuildResult != 0)
+            if (msbuildExitCode != ExitCodes.Success)
             {
-                VSTestTrace.SafeWriteTrace(() => LocalizableStrings.CmdMSBuildProjectsPropertiesErrorMessage);
+                VSTestTrace.SafeWriteTrace(() => string.Format(LocalizableStrings.CmdMSBuildProjectsPropertiesErrorMessage, msbuildExitCode));
                 return false;
             }
 
@@ -272,7 +273,7 @@ private void OnTestProcessExited(object sender, TestProcessExitEventArgs args)
                 return;
             }
 
-            if (args.ExitCode != 0)
+            if (args.ExitCode != ExitCodes.Success)
             {
                 VSTestTrace.SafeWriteTrace(() => $"Test Process exited with non-zero exit code: {args.ExitCode}");
             }