Merge pull request #37 from Microsoft/master

FI master to release/1.0
microsoft · May 29, 2018 · 415a605 · 415a605
2 parents dd7047e + a860e02
commit 415a605
Show file tree

Hide file tree

Showing 4 changed files with 73 additions and 14 deletions.
diff --git a/appveyor.yml b/appveyor.yml
@@ -0,0 +1,10 @@
+version: '{build}'
+image: Visual Studio 2017
+build:
+  project: MSBuildLocator.sln
+  publish_nuget: true
+  parallel: true
+  verbosity: minimal
+
+artifacts:
+- path: src\**\*.nupkg
diff --git a/samples/BuilderApp/BuilderApp.csproj b/samples/BuilderApp/BuilderApp.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net46</TargetFramework>
+    <TargetFramework>net471</TargetFramework>
     <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
     <IsPackable>false</IsPackable>
   </PropertyGroup>

diff --git a/samples/BuilderApp/Program.cs b/samples/BuilderApp/Program.cs
@@ -24,14 +24,24 @@ private static void Main(string[] args)
             //   1) Use defaults and call: MSBuildLocator.RegisterDefaults();
             //   2) Do something fancier and ask the user. As an example we'll do that.
             var instances = MSBuildLocator.QueryVisualStudioInstances().ToList();
-            var instanceToUse = AskWhichVisualStudioInstanceToUse(instances);
+            var msbuildDeploymentToUse = AskWhichMSBuildToUse(instances);
 
-            // Calling RegisterInstance will subscribe to AssemblyResolve event. After this we can now
+            // Calling Register methods will subscribe to AssemblyResolve event. After this we can
             // safely call code that use MSBuild types (in the Builder class).
-            MSBuildLocator.RegisterInstance(instanceToUse);
+            if (msbuildDeploymentToUse.VSInstance != null)
+            {
+                Console.WriteLine($"Using MSBuild from VS Instance: {msbuildDeploymentToUse.VSInstance.Name} - {msbuildDeploymentToUse.VSInstance.Version}");
+                Console.WriteLine();
 
-            Console.WriteLine($"Using VS Instance: {instanceToUse.Name} - {instanceToUse.Version}");
-            Console.WriteLine();
+                MSBuildLocator.RegisterInstance(msbuildDeploymentToUse.VSInstance);
+            }
+            else
+            {
+                Console.WriteLine($"Using MSBuild from path: {msbuildDeploymentToUse.MSBuildPath}");
+                Console.WriteLine();
+
+                MSBuildLocator.RegisterMSBuildPath(msbuildDeploymentToUse.MSBuildPath);
+            }
 
             var result = new Builder().Build(projectFilePath);
             Console.WriteLine();
@@ -41,14 +51,14 @@ private static void Main(string[] args)
             Console.ResetColor();
         }
 
-        private static VisualStudioInstance AskWhichVisualStudioInstanceToUse(List<VisualStudioInstance> instances)
+        private static (VisualStudioInstance VSInstance, string MSBuildPath) AskWhichMSBuildToUse(List<VisualStudioInstance> instances)
         {
             if (instances.Count == 0)
             {
-                Console.WriteLine("MSBuild not found! Exiting.");
-                Environment.Exit(-1);
+                Console.WriteLine("No Visual Studio instances found!");
             }
 
+            Console.WriteLine($"0) Custom path");
             for (var i = 1; i <= instances.Count; i++)
             {
                 var instance = instances[i - 1];
@@ -65,19 +75,36 @@ private static VisualStudioInstance AskWhichVisualStudioInstanceToUse(List<Visua
             Console.WriteLine();
             Console.WriteLine("Select an instance of MSBuild: ");
             var answer = Console.ReadLine();
-            VisualStudioInstance instanceUsed = null;
 
-            if (int.TryParse(answer, out int instanceChoice) && instanceChoice > 0 && instanceChoice <= instances.Count)
+            if (int.TryParse(answer, out int instanceChoice) && instanceChoice >= 0 && instanceChoice <= instances.Count)
             {
-                instanceUsed = instances[instanceChoice - 1];
+                if (instanceChoice == 0)
+                {
+                    Console.WriteLine("Input path to MSBuild deployment:");
+                    var msbuildPath = Console.ReadLine();
+
+                    if (!Directory.Exists(msbuildPath))
+                    {
+                        Console.WriteLine($"Directory does not exist: {msbuildPath}");
+                        Environment.Exit(-1);
+                    }
+
+                    return (null, msbuildPath);
+
+                }
+                else
+                {
+                    var instanceUsed = instances[instanceChoice - 1];
+                    return (instanceUsed, null);
+                }
             }
             else
             {
                 Console.WriteLine($"{answer} is not a valid response.");
                 Environment.Exit(-1);
             }
 
-            return instanceUsed;
+            throw new Exception("Invalid parsing");
         }
 
         private static void Header()

diff --git a/src/MSBuildLocator/MSBuildLocator.cs b/src/MSBuildLocator/MSBuildLocator.cs
@@ -69,6 +69,22 @@ public static void RegisterInstance(VisualStudioInstance instance)
             if (instance == null)
                 throw new ArgumentNullException(nameof(instance));
 
+            RegisterMSBuildPath(instance.MSBuildPath);
+        }
+
+        /// <summary>
+        ///     Add assembly resolution for Microsoft.Build core dlls in the current AppDomain from the specified
+        ///     path.
+        /// </summary>
+        /// <param name="msbuildPath">
+        ///     Path to the directory containing a deployment of MSBuild binaries.
+        ///     A minimal MSBuild deployment would be the publish result of the Microsoft.Build.Runtime package.
+        ///
+        ///     In order to restore and build real projects, one needs a deployment that contains the rest of the toolchain (nuget, compilers, etc.).
+        ///     Such deployments can be found in installations such as Visual Studio or dotnet CLI.
+        /// </param>
+        public static void RegisterMSBuildPath(string msbuildPath)
+        {
             var loadedMSBuildAssemblies = AppDomain.CurrentDomain.GetAssemblies().Where(IsMSBuildAssembly);
             if (loadedMSBuildAssemblies.Any())
             {
@@ -89,7 +105,7 @@ public static void RegisterInstance(VisualStudioInstance instance)
                 var assemblyName = new AssemblyName(eventArgs.Name);
                 if (IsMSBuildAssembly(assemblyName))
                 {
-                    var targetAssembly = Path.Combine(instance.MSBuildPath, assemblyName.Name + ".dll");
+                    var targetAssembly = Path.Combine(msbuildPath, assemblyName.Name + ".dll");
                     return File.Exists(targetAssembly) ? Assembly.LoadFrom(targetAssembly) : null;
                 }
 
@@ -143,6 +159,12 @@ private static VisualStudioInstance GetDevConsoleInstance()
                 Version version;
                 Version.TryParse(versionString, out version);
 
+                if (version == null && versionString?.Contains('-') == true)
+                {
+                    versionString = versionString.Substring(0, versionString.IndexOf('-'));
+                    Version.TryParse(versionString, out version);
+                }
+
                 if (version == null)
                 {
                     versionString = Environment.GetEnvironmentVariable("VisualStudioVersion");