void InitializeProperties(ProjectRootElement xml, ProjectInstance parent) { #if NET_4_5 location = xml.Location; #endif full_path = xml.FullPath; directory = string.IsNullOrWhiteSpace(xml.DirectoryPath) ? System.IO.Directory.GetCurrentDirectory() : xml.DirectoryPath; DefaultTargets = GetDefaultTargets(xml); InitialTargets = xml.InitialTargets.Split(item_target_sep, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToList(); raw_imports = new List <ResolvedImport> (); item_definitions = new Dictionary <string, ProjectItemDefinitionInstance> (); targets = new Dictionary <string, ProjectTargetInstance> (); raw_items = new List <ProjectItemInstance> (); // FIXME: this is likely hack. Test ImportedProject.Properties to see what exactly should happen. if (parent != null) { properties = parent.properties; } else { properties = new List <ProjectPropertyInstance> (); foreach (DictionaryEntry p in Environment.GetEnvironmentVariables()) { // FIXME: this is kind of workaround for unavoidable issue that PLATFORM=* is actually given // on some platforms and that prevents setting default "PLATFORM=AnyCPU" property. if (!string.Equals("PLATFORM", (string)p.Key, StringComparison.OrdinalIgnoreCase)) { this.properties.Add(new ProjectPropertyInstance((string)p.Key, false, (string)p.Value)); } } foreach (var p in global_properties) { this.properties.Add(new ProjectPropertyInstance(p.Key, false, p.Value)); } var tools = projects.GetToolset(tools_version) ?? projects.GetToolset(projects.DefaultToolsVersion); foreach (var p in projects.GetReservedProperties(tools, this, xml)) { this.properties.Add(p); } foreach (var p in ProjectCollection.GetWellKnownProperties(this)) { this.properties.Add(p); } } ProcessXml(parent, xml); }
public void TestGenerateSubToolsetVersion_ExplicitlyPassedGlobalPropertyWins() { string originalVisualStudioVersion = Environment.GetEnvironmentVariable("VisualStudioVersion"); try { Environment.SetEnvironmentVariable("VisualStudioVersion", ObjectModelHelpers.CurrentVisualStudioVersion); IDictionary <string, string> globalProperties = new Dictionary <string, string>(); globalProperties.Add("VisualStudioVersion", "v13.0"); ProjectCollection projectCollection = new ProjectCollection(globalProperties); Toolset parentToolset = projectCollection.GetToolset("4.0"); Toolset t = new Toolset("Fake", parentToolset.ToolsPath, null, projectCollection, null, parentToolset.OverrideTasksPath); IDictionary <string, string> explicitGlobalProperties = new Dictionary <string, string>(); explicitGlobalProperties.Add("VisualStudioVersion", "FakeSubToolset"); Assert.Equal("FakeSubToolset", t.GenerateSubToolsetVersion(explicitGlobalProperties, 0)); } finally { Environment.SetEnvironmentVariable("VisualStudioVersion", originalVisualStudioVersion); } }
public void TestGenerateSubToolsetVersionWhenNoSubToolset() { string originalVisualStudioVersion = Environment.GetEnvironmentVariable("VisualStudioVersion"); try { Environment.SetEnvironmentVariable("VisualStudioVersion", null); ProjectCollection projectCollection = new ProjectCollection(); Toolset parentToolset = projectCollection.GetToolset("4.0"); Toolset t = new Toolset("Fake", parentToolset.ToolsPath, null, projectCollection, null, parentToolset.OverrideTasksPath); string subToolsetVersion = t.GenerateSubToolsetVersion(); if (Toolset.Dev10IsInstalled) { Assert.Equal(Constants.Dev10SubToolsetValue, subToolsetVersion); } else { Assert.Null(subToolsetVersion); } } finally { Environment.SetEnvironmentVariable("VisualStudioVersion", originalVisualStudioVersion); } }
public void TestGenerateSubToolsetVersionWhenNoSubToolset() { if (NativeMethodsShared.IsUnixLike) { return; // "TODO: Under Unix this test throws. Investigate" } string originalVisualStudioVersion = Environment.GetEnvironmentVariable("VisualStudioVersion"); try { Environment.SetEnvironmentVariable("VisualStudioVersion", null); ProjectCollection projectCollection = new ProjectCollection(); Toolset parentToolset = projectCollection.GetToolset(ObjectModelHelpers.MSBuildDefaultToolsVersion); Toolset t = new Toolset("Fake", parentToolset.ToolsPath, null, projectCollection, null, parentToolset.OverrideTasksPath); string subToolsetVersion = t.GenerateSubToolsetVersion(); if (Toolset.Dev10IsInstalled) { Assert.Equal(Constants.Dev10SubToolsetValue, subToolsetVersion); } else { Assert.Null(subToolsetVersion); } } finally { Environment.SetEnvironmentVariable("VisualStudioVersion", originalVisualStudioVersion); } }
public void TestDefaultWhenNoSubToolset() { string originalVisualStudioVersion = Environment.GetEnvironmentVariable("VisualStudioVersion"); try { Environment.SetEnvironmentVariable("VisualStudioVersion", null); ProjectCollection projectCollection = new ProjectCollection(); Toolset parentToolset = projectCollection.GetToolset(ObjectModelHelpers.MSBuildDefaultToolsVersion); Toolset t = new Toolset("Fake", parentToolset.ToolsPath, null, projectCollection, null, parentToolset.OverrideTasksPath); if (Toolset.Dev10IsInstalled) { Assert.Equal(Constants.Dev10SubToolsetValue, t.DefaultSubToolsetVersion); } else { Assert.Null(t.DefaultSubToolsetVersion); } } finally { Environment.SetEnvironmentVariable("VisualStudioVersion", originalVisualStudioVersion); } }
/// <summary> /// Create an MSBuild project collection. /// </summary> /// <param name="solutionDirectory"> /// The base (i.e. solution) directory. /// </param> /// <param name="runtimeInfo"> /// Information about the current .NET Core runtime. /// </param> /// <param name="globalPropertyOverrides"> /// An optional dictionary containing property values to override. /// </param> /// <returns> /// The project collection. /// </returns> public static ProjectCollection CreateProjectCollection(string solutionDirectory, DotNetRuntimeInfo runtimeInfo, Dictionary <string, string> globalPropertyOverrides = null) { if (String.IsNullOrWhiteSpace(solutionDirectory)) { throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'baseDir'.", nameof(solutionDirectory)); } if (runtimeInfo == null) { throw new ArgumentNullException(nameof(runtimeInfo)); } if (String.IsNullOrWhiteSpace(runtimeInfo.BaseDirectory)) { throw new InvalidOperationException("Cannot determine base directory for .NET Core (check the output of 'dotnet --info')."); } Dictionary <string, string> globalProperties = CreateGlobalMSBuildProperties(runtimeInfo, solutionDirectory, globalPropertyOverrides); EnsureMSBuildEnvironment(globalProperties); ProjectCollection projectCollection = new ProjectCollection(globalProperties) { IsBuildEnabled = false }; SemanticVersion netcoreVersion; if (!SemanticVersion.TryParse(runtimeInfo.Version, out netcoreVersion)) { throw new FormatException($"Cannot parse .NET Core version '{runtimeInfo.Version}' (does not appear to be a valid semantic version)."); } // For .NET Core 3.0 and newer, toolset version is simply "Current" instead of "15.0" (tintoy/msbuild-project-tools-vscode#46). string toolsVersion = netcoreVersion.Major < 3 ? "15.0" : "Current"; // Override toolset paths (for some reason these point to the main directory where the dotnet executable lives). Toolset toolset = projectCollection.GetToolset(toolsVersion); toolset = new Toolset(toolsVersion, toolsPath: runtimeInfo.BaseDirectory, projectCollection: projectCollection, msbuildOverrideTasksPath: "" ); // Other toolset versions won't be supported by the .NET Core SDK projectCollection.RemoveAllToolsets(); // TODO: Add configuration setting that enables user to configure custom toolsets. projectCollection.AddToolset(toolset); projectCollection.DefaultToolsVersion = toolsVersion; return(projectCollection); }
/// <summary> /// Creates a standard ProjectCollection and adds a fake toolset with the following contents to it: /// /// ToolsVersion = Fake /// Base Properties: /// a = a1 /// b = b1 /// /// SubToolset "12.0": /// d = d4 /// e = e5 /// /// SubToolset "v11.0": /// b = b2 /// c = c2 /// /// SubToolset "FakeSubToolset": /// a = a3 /// c = c3 /// /// SubToolset "v13.0": /// f = f6 /// g = g7 /// </summary> private Toolset GetFakeToolset(IDictionary <string, string> globalPropertiesForProjectCollection) { ProjectCollection projectCollection = new ProjectCollection(globalPropertiesForProjectCollection); IDictionary <string, string> properties = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); properties.Add("a", "a1"); properties.Add("b", "b1"); Dictionary <string, SubToolset> subToolsets = new Dictionary <string, SubToolset>(StringComparer.OrdinalIgnoreCase); // SubToolset 12.0 properties PropertyDictionary <ProjectPropertyInstance> subToolset12Properties = new PropertyDictionary <ProjectPropertyInstance>(); subToolset12Properties.Set(ProjectPropertyInstance.Create("d", "d4")); subToolset12Properties.Set(ProjectPropertyInstance.Create("e", "e5")); // SubToolset v11.0 properties PropertyDictionary <ProjectPropertyInstance> subToolset11Properties = new PropertyDictionary <ProjectPropertyInstance>(); subToolset11Properties.Set(ProjectPropertyInstance.Create("b", "b2")); subToolset11Properties.Set(ProjectPropertyInstance.Create("c", "c2")); // FakeSubToolset properties PropertyDictionary <ProjectPropertyInstance> fakeSubToolsetProperties = new PropertyDictionary <ProjectPropertyInstance>(); fakeSubToolsetProperties.Set(ProjectPropertyInstance.Create("a", "a3")); fakeSubToolsetProperties.Set(ProjectPropertyInstance.Create("c", "c3")); // SubToolset v13.0 properties PropertyDictionary <ProjectPropertyInstance> subToolset13Properties = new PropertyDictionary <ProjectPropertyInstance>(); subToolset13Properties.Set(ProjectPropertyInstance.Create("f", "f6")); subToolset13Properties.Set(ProjectPropertyInstance.Create("g", "g7")); subToolsets.Add("12.0", new SubToolset("12.0", subToolset12Properties)); subToolsets.Add("v11.0", new SubToolset("v11.0", subToolset11Properties)); subToolsets.Add("FakeSubToolset", new SubToolset("FakeSubToolset", fakeSubToolsetProperties)); subToolsets.Add("v13.0", new SubToolset("v13.0", subToolset13Properties)); Toolset parentToolset = projectCollection.GetToolset("4.0"); Toolset fakeToolset = new Toolset("Fake", parentToolset.ToolsPath, properties, projectCollection, subToolsets, parentToolset.OverrideTasksPath); projectCollection.AddToolset(fakeToolset); return(fakeToolset); }
public void TestNoSubToolset_EnvironmentOverrides() { string originalVisualStudioVersion = Environment.GetEnvironmentVariable("VisualStudioVersion"); try { Environment.SetEnvironmentVariable("VisualStudioVersion", "foo"); ProjectCollection projectCollection = new ProjectCollection(); Toolset parentToolset = projectCollection.GetToolset("4.0"); Toolset t = new Toolset("Fake", parentToolset.ToolsPath, null, projectCollection, null, parentToolset.OverrideTasksPath); Assert.Equal("foo", t.GenerateSubToolsetVersion()); } finally { Environment.SetEnvironmentVariable("VisualStudioVersion", originalVisualStudioVersion); } }
/// <summary> /// Create an MSBuild project collection. /// </summary> /// <param name="solutionDirectory"> /// The base (i.e. solution) directory. /// </param> /// <param name="runtimeInfo"> /// Information about the current .NET Core runtime. /// </param> /// <returns> /// The project collection. /// </returns> public static ProjectCollection CreateProjectCollection(string solutionDirectory, DotNetRuntimeInfo runtimeInfo) { if (String.IsNullOrWhiteSpace(solutionDirectory)) { throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'baseDir'.", nameof(solutionDirectory)); } if (runtimeInfo == null) { throw new ArgumentNullException(nameof(runtimeInfo)); } if (String.IsNullOrWhiteSpace(runtimeInfo.BaseDirectory)) { throw new InvalidOperationException("Cannot determine base directory for .NET Core."); } Dictionary <string, string> globalProperties = CreateGlobalMSBuildProperties(runtimeInfo, solutionDirectory); EnsureMSBuildEnvironment(globalProperties); ProjectCollection projectCollection = new ProjectCollection(globalProperties) { IsBuildEnabled = false }; // Override toolset paths (for some reason these point to the main directory where the dotnet executable lives). Toolset toolset = projectCollection.GetToolset("15.0"); toolset = new Toolset( toolsVersion: "15.0", toolsPath: globalProperties["MSBuildExtensionsPath"], projectCollection: projectCollection, msbuildOverrideTasksPath: "" ); projectCollection.AddToolset(toolset); return(projectCollection); }
public void TestNoSubToolset_GlobalPropertyOverrides() { string originalVisualStudioVersion = Environment.GetEnvironmentVariable("VisualStudioVersion"); try { Environment.SetEnvironmentVariable("VisualStudioVersion", null); IDictionary <string, string> globalProperties = new Dictionary <string, string>(); globalProperties.Add("VisualStudioVersion", "99.0"); ProjectCollection projectCollection = new ProjectCollection(globalProperties); Toolset parentToolset = projectCollection.GetToolset("4.0"); Toolset t = new Toolset("Fake", parentToolset.ToolsPath, null, projectCollection, null, parentToolset.OverrideTasksPath); Assert.Equal("99.0", t.GenerateSubToolsetVersion()); } finally { Environment.SetEnvironmentVariable("VisualStudioVersion", originalVisualStudioVersion); } }
public void Execute() { bool result = false; bool show_stacktrace = false; try { parameters.ParseArguments(args); show_stacktrace = (parameters.LoggerVerbosity == LoggerVerbosity.Detailed || parameters.LoggerVerbosity == LoggerVerbosity.Diagnostic); if (!parameters.NoLogo) { ErrorUtilities.ShowVersion(false); } project_collection = new ProjectCollection(); if (!String.IsNullOrEmpty(parameters.ToolsVersion)) { if (project_collection.GetToolset(parameters.ToolsVersion) == null) { ErrorUtilities.ReportError(0, new InvalidToolsetDefinitionException("Toolset " + parameters.ToolsVersion + " was not found").Message); } project_collection.DefaultToolsVersion = parameters.ToolsVersion; } foreach (var p in parameters.Properties) { project_collection.GlobalProperties.Add(p.Key, p.Value); } if (!parameters.NoConsoleLogger) { printer = new ConsoleReportPrinter(); ConsoleLogger cl = new ConsoleLogger(parameters.LoggerVerbosity, printer.Print, printer.SetForeground, printer.ResetColor); cl.Parameters = parameters.ConsoleLoggerParameters; cl.Verbosity = parameters.LoggerVerbosity; project_collection.RegisterLogger(cl); } if (parameters.FileLoggerParameters != null) { for (int i = 0; i < parameters.FileLoggerParameters.Length; i++) { string fl_params = parameters.FileLoggerParameters [i]; if (fl_params == null) { continue; } var fl = new FileLogger(); if (fl_params.Length == 0 && i > 0) { fl.Parameters = String.Format("LogFile=msbuild{0}.log", i); } else { fl.Parameters = fl_params; } project_collection.RegisterLogger(fl); } } foreach (LoggerInfo li in parameters.Loggers) { Assembly assembly; if (li.InfoType == LoadInfoType.AssemblyFilename) { assembly = Assembly.LoadFrom(li.Filename); } else { assembly = Assembly.Load(li.AssemblyName); } ILogger logger = (ILogger)Activator.CreateInstance(assembly.GetType(li.ClassName)); logger.Parameters = li.Parameters; project_collection.RegisterLogger(logger); } string projectFile = parameters.ProjectFile; if (!File.Exists(projectFile)) { ErrorUtilities.ReportError(0, String.Format("Project file '{0}' not found.", projectFile)); return; } XmlReaderSettings settings = new XmlReaderSettings(); if (parameters.Validate) { settings.ValidationType = ValidationType.Schema; if (parameters.ValidationSchema == null) { using (var xsdxml = XmlReader.Create(defaultSchema)) settings.Schemas.Add(XmlSchema.Read(xsdxml, null)); } else { using (var xsdxml = XmlReader.Create(parameters.ValidationSchema)) settings.Schemas.Add(XmlSchema.Read(xsdxml, null)); } } var projectInstances = new List <ProjectInstance> (); if (string.Equals(Path.GetExtension(projectFile), ".sln", StringComparison.OrdinalIgnoreCase)) { var parser = new SolutionParser(); var root = ProjectRootElement.Create(project_collection); root.FullPath = projectFile; parser.ParseSolution(projectFile, project_collection, root, LogWarning); projectInstances.Add(new Project(root, parameters.Properties, parameters.ToolsVersion, project_collection).CreateProjectInstance()); } else { project = ProjectRootElement.Create(XmlReader.Create(projectFile, settings), project_collection); project.FullPath = projectFile; var pi = new ProjectInstance(project, parameters.Properties, parameters.ToolsVersion, project_collection); projectInstances.Add(pi); } foreach (var projectInstance in projectInstances) { var targets = parameters.Targets.Length > 0 ? parameters.Targets : projectInstance.DefaultTargets.ToArray(); result = projectInstance.Build(targets, parameters.Loggers.Count > 0 ? parameters.Loggers : project_collection.Loggers); if (!result) { break; } } } catch (InvalidProjectFileException ipfe) { ErrorUtilities.ReportError(0, show_stacktrace ? ipfe.ToString() : ipfe.Message); } catch (InternalLoggerException ile) { ErrorUtilities.ReportError(0, show_stacktrace ? ile.ToString() : ile.Message); } catch (CommandLineException cle) { ErrorUtilities.ReportError(cle.ErrorCode, show_stacktrace ? cle.ToString() : cle.Message); } finally { //if (project_collection != null) // project_collection.UnregisterAllLoggers (); Environment.Exit(result ? 0 : 1); } }
string [] GetDefaultTargets(ProjectRootElement xml, bool fromAttribute, bool checkImports) { if (fromAttribute) { var ret = xml.DefaultTargets.Split(item_target_sep, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray(); if (checkImports && ret.Length == 0) { foreach (var imp in this.raw_imports) { ret = GetDefaultTargets(imp.ImportedProject, true, false); if (ret.Any()) { break; } } } return(ret); } else { if (xml.Targets.Any()) { return new String [] { xml.Targets.First().Name } } ; if (checkImports) { foreach (var imp in this.raw_imports) { var ret = GetDefaultTargets(imp.ImportedProject, false, false); if (ret.Any()) { return(ret); } } } return(new string [0]); } } void InitializeProperties(ProjectRootElement xml) { location = xml.Location; full_path = xml.FullPath; directory = string.IsNullOrWhiteSpace(xml.DirectoryPath) ? System.IO.Directory.GetCurrentDirectory() : xml.DirectoryPath; InitialTargets = xml.InitialTargets.Split(item_target_sep, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToList(); raw_imports = new List <ResolvedImport> (); item_definitions = new Dictionary <string, ProjectItemDefinitionInstance> (); targets = new Dictionary <string, ProjectTargetInstance> (); raw_items = new List <ProjectItemInstance> (); properties = new Dictionary <string, ProjectPropertyInstance> (); foreach (DictionaryEntry p in Environment.GetEnvironmentVariables()) { // FIXME: this is kind of workaround for unavoidable issue that PLATFORM=* is actually given // on some platforms and that prevents setting default "PLATFORM=AnyCPU" property. if (!string.Equals("PLATFORM", (string)p.Key, StringComparison.OrdinalIgnoreCase)) { this.properties [(string)p.Key] = new ProjectPropertyInstance((string)p.Key, true, (string)p.Value); } } foreach (var p in global_properties) { this.properties [p.Key] = new ProjectPropertyInstance(p.Key, false, p.Value); } var tools = projects.GetToolset(tools_version) ?? projects.GetToolset(projects.DefaultToolsVersion); foreach (var p in projects.GetReservedProperties(tools, this, xml)) { this.properties [p.Name] = p; } foreach (var p in ProjectCollection.GetWellKnownProperties(this)) { this.properties [p.Name] = p; } ProcessXml(xml); DefaultTargets = GetDefaultTargets(xml).ToList(); }