public void ItemsAndProperties () { string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'> <ItemGroup> <X Condition='false' Include='bar.txt' /> <X Include='foo.txt'> <M>m</M> <N>=</N> </X> </ItemGroup> <PropertyGroup> <P Condition='false'>void</P> <P Condition='true'>valid</P> </PropertyGroup> </Project>"; var xml = XmlReader.Create (new StringReader(project_xml)); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root); var item = proj.Items.First (); Assert.AreEqual ("foo.txt", item.EvaluatedInclude, "#1"); var prop = proj.Properties.First (p => p.Name=="P"); Assert.AreEqual ("valid", prop.EvaluatedValue, "#2"); Assert.IsNotNull (proj.GetProperty ("MSBuildProjectDirectory"), "#3"); Assert.AreEqual ("4.0", proj.ToolsVersion, "#4"); }
/// <summary> /// Builds a project. /// </summary> /// <param name="projectInstance">The project to build.</param> /// <param name="targetsToBuild">The targets to build. If not specified, the project's default target will be invoked.</param> /// <returns>A task whose result is the result of the build.</returns> public static async Task<BuildResultAndLogs> ExecuteAsync(ProjectInstance projectInstance, params string[] targetsToBuild) { targetsToBuild = (targetsToBuild == null || targetsToBuild.Length == 0) ? projectInstance.DefaultTargets.ToArray() : targetsToBuild; var logger = new EventLogger(); var logLines = new List<string>(); var parameters = new BuildParameters { Loggers = new List<ILogger> { new ConsoleLogger(LoggerVerbosity.Detailed, logLines.Add, null, null), logger, }, }; BuildResult result; using (var buildManager = new BuildManager()) { buildManager.BeginBuild(parameters); try { var brdFlags = BuildRequestDataFlags.ProvideProjectStateAfterBuild; var requestData = new BuildRequestData(projectInstance, targetsToBuild, null, brdFlags); var submission = buildManager.PendBuildRequest(requestData); result = await submission.ExecuteAsync(); } finally { buildManager.EndBuild(); } } return new BuildResultAndLogs(result, logger.LogEvents, logLines); }
public void TestResolveEnvironment() { var proj1 = new ProjectInstance(TestData.GetPath(@"TestData\Targets\Environments1.pyproj")); Assert.IsTrue(proj1.Build("TestResolveEnvironment", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed) })); var proj2 = new ProjectInstance(TestData.GetPath(@"TestData\Targets\Environments2.pyproj")); Assert.IsTrue(proj2.Build("TestResolveEnvironment", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed) })); }
public void OutputPropertyExists () { string project_xml = @" <Project DefaultTargets='Build' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'> <PropertyGroup> <C>False</C> </PropertyGroup> <Target Name='Build' DependsOnTargets='ResolveReferences' /> <Target Name='Build2' DependsOnTargets='Bar' /> <Target Name='ResolveReferences' DependsOnTargets='Foo;Bar' /> <Target Name='Foo'> <CreateProperty Value='True'> <Output TaskParameter='Value' PropertyName='C' /> </CreateProperty> </Target> <Target Name='Bar' Condition='!($(C))' DependsOnTargets='ResolveReferences'> </Target> </Project>"; var xml = XmlReader.Create (new StringReader(project_xml)); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root); Assert.AreEqual (5, proj.Targets.Count, "#1"); var foo = proj.Targets ["Foo"]; Assert.IsNotNull (foo, "#2"); Assert.AreEqual (1, foo.Tasks.Count, "#3"); var cp = foo.Tasks.First (); Assert.AreEqual (1, cp.Outputs.Count, "#4"); var po = cp.Outputs.First () as ProjectTaskOutputPropertyInstance; Assert.IsNotNull (po, "#5"); Assert.AreEqual ("C", po.PropertyName, "#5"); proj.Build ("Build", null); Assert.AreEqual (string.Empty, foo.Outputs, "#6"); Assert.AreEqual ("True", proj.GetPropertyValue ("C"), "#7"); }
internal static async Task<BuildResult> BuildAsync(this BuildManager buildManager, ITestOutputHelper logger, ProjectCollection projectCollection, ProjectRootElement project, string target, IDictionary<string, string> globalProperties = null, LoggerVerbosity logVerbosity = LoggerVerbosity.Detailed, ILogger[] additionalLoggers = null) { Requires.NotNull(buildManager, nameof(buildManager)); Requires.NotNull(projectCollection, nameof(projectCollection)); Requires.NotNull(project, nameof(project)); globalProperties = globalProperties ?? new Dictionary<string, string>(); var projectInstance = new ProjectInstance(project, globalProperties, null, projectCollection); var brd = new BuildRequestData(projectInstance, new[] { target }, null, BuildRequestDataFlags.ProvideProjectStateAfterBuild); var parameters = new BuildParameters(projectCollection); var loggers = new List<ILogger>(); loggers.Add(new ConsoleLogger(logVerbosity, s => logger.WriteLine(s.TrimEnd('\r', '\n')), null, null)); loggers.AddRange(additionalLoggers); parameters.Loggers = loggers.ToArray(); buildManager.BeginBuild(parameters); var result = await buildManager.BuildAsync(brd); buildManager.EndBuild(); return result; }
protected virtual IEnumerable <ProjectFileReference> GetProjectReferences(MSB.Execution.ProjectInstance executedProject) { return(executedProject.GetItems("ProjectReference") .Select(reference => new ProjectFileReference( path: reference.EvaluatedInclude, aliases: default(ImmutableArray <string>)))); }
private void GetReferences( CSharpCompilerInputs compilerInputs, MSB.Execution.ProjectInstance executedProject, out IEnumerable <MetadataReference> metadataReferences, out IEnumerable <AnalyzerReference> analyzerReferences) { // use command line parser to do reference translation same as command line compiler var args = new List <string>(); if (compilerInputs.LibPaths != null && compilerInputs.LibPaths.Count > 0) { args.Add("/lib:\"" + string.Join(";", compilerInputs.LibPaths) + "\""); } foreach (var mr in compilerInputs.References) { var filePath = GetDocumentFilePath(mr); var aliases = GetAliases(mr); if (aliases.IsDefaultOrEmpty) { args.Add("/r:\"" + filePath + "\""); } else { foreach (var alias in aliases) { args.Add("/r:" + alias + "=\"" + filePath + "\""); } } } foreach (var ar in compilerInputs.AnalyzerReferences) { var filePath = GetDocumentFilePath(ar); args.Add("/a:\"" + filePath + "\""); } if (compilerInputs.NoStandardLib) { args.Add("/nostdlib"); } var commandLineParser = CSharpCommandLineParser.Default; var commandLineArgs = commandLineParser.Parse(args, executedProject.Directory, RuntimeEnvironment.GetRuntimeDirectory()); var resolver = new MetadataFileReferenceResolver(commandLineArgs.ReferencePaths, commandLineArgs.BaseDirectory); metadataReferences = commandLineArgs.ResolveMetadataReferences(new AssemblyReferenceResolver(resolver, _metadataService.GetProvider())); var analyzerLoader = _analyzerService.GetLoader(); foreach (var path in commandLineArgs.AnalyzerReferences.Select(r => r.FilePath)) { analyzerLoader.AddDependencyLocation(path); } analyzerReferences = commandLineArgs.ResolveAnalyzerReferences(analyzerLoader); }
public static void AssertPropertyDoesNotExist(ProjectInstance projectInstance, string propertyName) { ProjectPropertyInstance propertyInstance = projectInstance.GetProperty(propertyName); string value = propertyInstance == null ? null : propertyInstance.EvaluatedValue; Assert.IsNull(propertyInstance, "Not expecting the property to exist. Property: {0}, Value: {1}", propertyName, value); }
public BuildRequestData (ProjectInstance projectInstance, string[] targetsToBuild, HostServices hostServices, BuildRequestDataFlags flags) { ProjectInstance = projectInstance; TargetNames = targetsToBuild; HostServices = hostServices; Flags = flags; }
public void ExplicitToolsVersion () { string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />"; var xml = XmlReader.Create (new StringReader(project_xml)); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root, null, "4.0", new ProjectCollection ()); Assert.AreEqual ("4.0", proj.ToolsVersion, "#1"); }
internal ProjectItemInstance (ProjectInstance project, string itemType, IEnumerable<KeyValuePair<string,string>> metadata, string evaluatedInclude) { this.project = project; this.evaluated_include = evaluatedInclude; this.item_type = itemType; this.metadata = new List<ProjectMetadataInstance> (); SetMetadata (metadata); }
public void DefaultTargetsEmpty () { string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'> </Project>"; var xml = XmlReader.Create (new StringReader (project_xml)); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root); Assert.AreEqual (new string [0], proj.DefaultTargets, "#1"); }
public virtual string GetConfigurationProperty(string propertyName, bool resetCache) { if (snapshot == null) snapshot = proj.CreateProjectInstance(config, platform); ProjectPropertyInstance property = snapshot.GetProperty(propertyName); if (property == null) return null; return property.EvaluatedValue; }
static ProjectInstance[] sortByBuildOrder(ProjectInstance[] instances) { var rootProjects = instances.ToDictionary(getProjectGuid); var ordered = rootProjects.Keys.SortTopologicallyReverse( g1 => getDependentProjectGuids(rootProjects[g1]).Where(rootProjects.ContainsKey)); return ordered.Select(g => rootProjects[g]).ToArray(); }
public Microsoft.Expression.Project.Build.BuildResult Build(IEnumerable <ILogger> loggers, params string[] targetNames) { Microsoft.Build.Execution.ProjectInstance projectInstance = new Microsoft.Build.Execution.ProjectInstance(this.CreateProject()); string[] strArrays = new string[] { "ResolveReferences", "MarkupCompilePass1" }; if (projectInstance.Build(strArrays, loggers)) { return(Microsoft.Expression.Project.Build.BuildResult.Succeeded); } return(Microsoft.Expression.Project.Build.BuildResult.Failed); }
public void DefaultTargetsFromAttribute () { string project_xml = @"<Project DefaultTargets='Foo Bar Baz;Foo' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'> </Project>"; var xml = XmlReader.Create (new StringReader (project_xml)); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root); string [] expected = {"Foo Bar Baz", "Foo"}; Assert.AreEqual (expected, proj.DefaultTargets, "#1"); }
public void ToStringOverride () { var xml = XmlReader.Create (new StringReader (project_xml)); string path = Path.GetFullPath ("foo.xml"); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root); var item = proj.Items.First (); Assert.AreEqual ("M=m", item.Metadata.First ().ToString (), "#1"); Assert.AreEqual ("N==", item.Metadata.Last ().ToString (), "#2"); // haha }
public BuildRequestData (ProjectInstance projectInstance, string[] targetsToBuild, HostServices hostServices, BuildRequestDataFlags flags) { if (targetsToBuild == null) throw new ArgumentNullException ("targetsToBuild"); ProjectInstance = projectInstance; TargetNames = targetsToBuild; HostServices = hostServices; Flags = flags; }
private IEnumerable<ProjectFileReference> GetProjectReferencesCore(ProjectInstance executedProject) { foreach (var projectReference in GetProjectReferenceItems(executedProject)) { var filePath = projectReference.EvaluatedInclude; var aliases = GetAliases(projectReference); yield return new ProjectFileReference(filePath, aliases); } }
public ExpressionEvaluator (ProjectInstance project, string replacementForMissingPropertyAndItem) { ReplacementForMissingPropertyAndItem = replacementForMissingPropertyAndItem; ProjectInstance = project; /* GetItems = (name) => project.GetItems (name).Select (i => new KeyValuePair<string,string> (i.ItemType, i.EvaluatedInclude)); GetProperty = (name) => { var prop = project.GetProperty (name); return new KeyValuePair<string,string> (prop != null ? prop.Name : null, prop != null ? prop.EvaluatedValue : null); }; */ }
public void NullTargetsToBuild () { string project_xml = @"<Project DefaultTargets='Foo' xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />"; var xml = XmlReader.Create (new StringReader (project_xml)); var root = ProjectRootElement.Create (xml); root.FullPath = "BuildRequestDataTest.NullTargetsToBuild.proj"; var pc = new ProjectCollection (); var sw = new StringWriter (); pc.RegisterLogger (new ConsoleLogger (LoggerVerbosity.Diagnostic, sw.WriteLine, null, null)); var proj = new ProjectInstance (root); new BuildRequestData (proj, null); }
public void BuildDoesNotIncreaseCollectionContent () { string empty_project_xml = "<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />"; var xml = XmlReader.Create (new StringReader (empty_project_xml)); var root = ProjectRootElement.Create (xml); var coll = new ProjectCollection (); var inst = new ProjectInstance (root, null, null, coll); root.FullPath = "ProjectCollectionTest.BuildDoesNotIncreaseCollectionContent.proj"; Assert.AreEqual (0, coll.Count, "#1"); inst.Build (); Assert.AreEqual (0, coll.Count, "#2"); }
public void ResultBeforeExecute () { string empty_project_xml = "<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />"; var path = "file://localhost/foo.xml"; var xml = XmlReader.Create (new StringReader (empty_project_xml), null, path); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root); var bm = new BuildManager (); bm.BeginBuild (new BuildParameters ()); var sub = bm.PendBuildRequest (new BuildRequestData (proj, new string [0])); Assert.IsNull (sub.BuildResult, "#1"); }
private void CreateProject() { try { _projectInstance = new ProjectInstance(_file.FullName); _project = _projects.LoadProject(_file.FullName); } catch (Exception error) { throw new BuildFileLoadException("Error parsing MSBuild project", error); } }
public Assembly CompileProject(string projectFilename, string configuration = "Debug") { var mgr = new BuildManager(); var parms = new BuildParameters(); var proj = new ProjectInstance(projectFilename); var req = new BuildRequestData(proj, new string[] {configuration}); BuildResult result = mgr.Build(parms, req); Console.WriteLine("Overall build result: {0}", result.OverallResult); throw new NotImplementedException("Not fully implemented yet"); }
static RelativeFileSet GetProjectFileSet(FilePath ProjectFile) { var isSqlProj = ProjectFile.Extension == "sqlproj"; var project = new MSE.ProjectInstance(ProjectFile); var items = isSqlProj ? project.FindItems(StandardItemTypes.Build, StandardItemTypes.None) : project.FindItems(StandardItemTypes.Compile, StandardItemTypes.None); var files = items.Map(item => new RelativePath(item.EvaluatedInclude)); return(new RelativeFileSet(ProjectFile.Folder, files)); }
public void IntTargets_TempFolderIsNotSet() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, null); // Act ProjectInstance projectInstance = new ProjectInstance(projectRoot.FullPath); // Assert BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.SonarQubeOutputPath); BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.SonarQubeConfigPath); }
private ProjectFileInfo CreateProjectFileInfo(VisualBasicProjectFileLoader.VisualBasicProjectFile.VisualBasicCompilerInputs compilerInputs, ProjectInstance executedProject) { string outputPath = Path.Combine(this.GetOutputDirectory(), compilerInputs.OutputFileName); string assemblyName = this.GetAssemblyName(); return new ProjectFileInfo( outputPath, assemblyName, compilerInputs.CommandLineArgs, this.GetDocuments(compilerInputs.Sources, executedProject), this.GetDocuments(compilerInputs.AdditionalFiles, executedProject), base.GetProjectReferences(executedProject)); }
// FIXME: // While we are not faced to implement those features, there are some modern task execution requirements. // // This will have to be available for "out of process" nodes (see NodeAffinity). // NodeAffinity is set per project file at BuildManager.HostServices. // When NodeAffinity is set to OutOfProc, it should probably launch different build host // that runs separate build tasks. (.NET has MSBuildTaskHost.exe which I guess is about that.) // // Also note that the complete implementation has to support LoadInSeparateAppDomainAttribute // (which is most likely derived from AppDomainIsolatedBuildTask) that marks a task to run // in separate AppDomain. // public void BuildProject (Func<bool> checkCancel, BuildResult result, ProjectInstance project, IEnumerable<string> targetNames, IDictionary<string,string> globalProperties, IDictionary<string,string> targetOutputs, string toolsVersion) { if (toolsVersion == null) throw new ArgumentNullException ("toolsVersion"); var parameters = submission.BuildManager.OngoingBuildParameters; var toolset = parameters.GetToolset (toolsVersion); if (toolset == null) throw new InvalidOperationException (string.Format ("Toolset version '{0}' was not resolved to valid toolset", toolsVersion)); LogMessageEvent (new BuildMessageEventArgs (string.Format ("Using Toolset version {0}.", toolsVersion), null, null, MessageImportance.Low)); var buildTaskFactory = new BuildTaskFactory (BuildTaskDatabase.GetDefaultTaskDatabase (toolset), new BuildTaskDatabase (this, submission.BuildRequest.ProjectInstance)); BuildProject (new InternalBuildArguments () { CheckCancel = checkCancel, Result = result, Project = project, TargetNames = targetNames, GlobalProperties = globalProperties, TargetOutputs = targetOutputs, ToolsVersion = toolsVersion, BuildTaskFactory = buildTaskFactory }); }
public void PropertiesCopiesValues () { var xml = XmlReader.Create (new StringReader (project_xml)); string path = Path.GetFullPath ("foo.xml"); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root); var item = proj.Items.First (); var md = item.Metadata.First (); Assert.AreEqual ("m", item.Metadata.First ().EvaluatedValue, "#1"); Assert.AreEqual ("m", root.ItemGroups.First ().Items.First ().Metadata.First ().Value, "#2"); root.ItemGroups.First ().Items.First ().Metadata.First ().Value = "X"; Assert.AreEqual ("m", item.Metadata.First ().EvaluatedValue, "#3"); }
private void OnProjectOpened(IVsHierarchy vsHierarchy) { // Register pipe url so that MSBuild can transfer it var vsProject = vsHierarchy as IVsProject; if (vsProject != null) { var dteProject = VsHelper.ToDteProject(vsProject); // We will only deal with .csproj files for now // Should we support C++/CLI .vcxproj as well? if (!dteProject.FileName.EndsWith(".csproj")) return; // Find current project active configuration var configManager = dteProject.ConfigurationManager; if (configManager == null) return; EnvDTE.Configuration activeConfig; try { activeConfig = configManager.ActiveConfiguration; } catch (Exception) { if (configManager.Count == 0) return; activeConfig = configManager.Item(1); } // Get global parameters for Configuration and Platform var globalProperties = new Dictionary<string, string>(); globalProperties["Configuration"] = activeConfig.ConfigurationName; globalProperties["Platform"] = activeConfig.PlatformName == "Any CPU" ? "AnyCPU" : activeConfig.PlatformName; // Check if project matches: Condition="'$(SiliconStudioCurrentPackagePath)' != '' and '$(SiliconStudioIsExecutable)' == 'true'" var projectInstance = new ProjectInstance(dteProject.FileName, globalProperties, null); var packagePathProperty = projectInstance.Properties.FirstOrDefault(x => x.Name == "SiliconStudioCurrentPackagePath"); var isExecutableProperty = projectInstance.Properties.FirstOrDefault(x => x.Name == "SiliconStudioIsExecutable"); if (packagePathProperty == null || isExecutableProperty == null || isExecutableProperty.EvaluatedValue.ToLowerInvariant() != "true") return; var buildProjects = ProjectCollection.GlobalProjectCollection.GetLoadedProjects(dteProject.FileName); foreach (var buildProject in buildProjects) { buildProject.SetGlobalProperty("SiliconStudioBuildEngineLogPipeUrl", logPipeUrl); } } }
public virtual void Invalidate() { // property cache will need to be updated this.currentConfig = null; this.currentUserConfig = null; // Signal the output groups that something is changed foreach (OutputGroup group in this.OutputGroups) { group.InvalidateGroup(); } this._project.SetProjectFileDirty(true); }
private MSBuildExecution.ProjectInstance GetCurrentConfig(bool resetCache = false) { if (resetCache || currentConfig == null) { // Get properties for current configuration from project file and cache it project.SetConfiguration(ConfigName); project.BuildProject.ReevaluateIfNecessary(); // Create a snapshot of the evaluated project in its current state currentConfig = project.BuildProject.CreateProjectInstance(); // Restore configuration project.SetCurrentConfiguration(); } return(currentConfig); }
public void DefaultTargetsFromElements () { string [] defaultTargetAtts = {string.Empty, "DefaultTargets=''"}; for (int i = 0; i < defaultTargetAtts.Length; i++) { string project_xml = string.Format (@"<Project {0} xmlns='http://schemas.microsoft.com/developer/msbuild/2003'> <Target Name='Foo' /> <Target Name='Bar' /> </Project>", defaultTargetAtts [i]); var xml = XmlReader.Create (new StringReader (project_xml)); var root = ProjectRootElement.Create (xml); var proj = new ProjectInstance (root); string [] expected = {"Foo"}; // Bar is not included Assert.AreEqual (expected, proj.DefaultTargets, "#1-" + i); } }
protected string GetItemString(MSB.Execution.ProjectInstance executedProject, string itemType) { string text = ""; foreach (var item in executedProject.GetItems(itemType)) { if (text.Length > 0) { text = text + " "; } text = text + item.EvaluatedInclude; } return(text); }
private IEnumerable<ProjectFileReference> GetProjectReferencesCore(ProjectInstance executedProject) { foreach (var projectReference in GetProjectReferenceItems(executedProject)) { Guid guid; if (!Guid.TryParse(projectReference.GetMetadataValue("Project"), out guid)) { continue; } var filePath = projectReference.EvaluatedInclude; var aliases = GetAliases(projectReference); yield return new ProjectFileReference(guid, filePath, aliases); } }
public virtual void SetConfigurationProperty(string propertyName, string propertyValue) { if (!this.project.QueryEditProjectFile(false)) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } string condition = String.Format(CultureInfo.InvariantCulture, ConfigProvider.configString, this.ConfigName); SetPropertyUnderCondition(propertyName, propertyValue, condition); // property cache will need to be updated this.currentConfig = null; return; }
public IReadOnlyList <FilePath> GetProjectFiles(FilePath ProjectFile) { try { var project = new MSEX.ProjectInstance(ProjectFile); var evaluations = project.Items.Map(item => (item.ItemType, item.EvaluatedInclude)); var paths = evaluations.Where(e => e.Item1 == "Build") .Select(x => ProjectFile.Folder.GetCombinedFilePath(x.Item2)).Where(f => f.Exists()).ToList(); return(paths); } catch (Exception e) { Notify(error($"Error occurred during evaluation of {ProjectFile}: {e}")); return(metacore.rolist <FilePath>()); } }
/// <summary> /// Factory for intrinsic tasks. /// </summary> /// <param name="taskInstance">The task instance object.</param> /// <param name="loggingContext">The logging context.</param> /// <param name="projectInstance">The project instance.</param> /// <returns>An instantiated intrinsic task.</returns> internal static IntrinsicTask InstantiateTask(ProjectTargetInstanceChild taskInstance, TargetLoggingContext loggingContext, ProjectInstance projectInstance, bool logTaskInputs) { if (taskInstance is ProjectPropertyGroupTaskInstance) { return new PropertyGroupIntrinsicTask(taskInstance as ProjectPropertyGroupTaskInstance, loggingContext, projectInstance, logTaskInputs); } else if (taskInstance is ProjectItemGroupTaskInstance) { return new ItemGroupIntrinsicTask(taskInstance as ProjectItemGroupTaskInstance, loggingContext, projectInstance, logTaskInputs); } else { ErrorUtilities.ThrowInternalError("Unhandled intrinsic task type {0}", taskInstance.GetType().BaseType); return null; } }
protected string ReadPropertyString(MSB.Execution.ProjectInstance executedProject, string executedPropertyName, string evaluatedPropertyName) { var executedProperty = executedProject.GetProperty(executedPropertyName); if (executedProperty != null) { return(executedProperty.EvaluatedValue); } var evaluatedProperty = _loadedProject.GetProperty(evaluatedPropertyName); if (evaluatedProperty != null) { return(evaluatedProperty.EvaluatedValue); } return(null); }
public Option <string> BuildSolution(FilePath SolutionPath) { var manager = MSEX.BuildManager.DefaultBuildManager; var project = new MSEX.ProjectInstance(SolutionPath); var logPath = SolutionPath.ChangeExtension("binlog"); var buildRequest = new MSEX.BuildRequestData(project, array("Build")); var result = manager.Build ( new MSEX.BuildParameters { Loggers = metacore.roitems <ILogger>(new MSL.ConsoleLogger()) }, buildRequest ); var targetResults = result.ResultsByTarget["Build"]; return(targetResults.ResultCode.ToString()); }
protected virtual MSBuildExecution.ProjectPropertyInstance GetMsBuildProperty(string propertyName, _PersistStorageType storageType, bool resetCache) { MSBuildExecution.ProjectInstance requestedConfig = storageType == _PersistStorageType.PST_PROJECT_FILE ? currentConfig : currentUserConfig; if (resetCache || requestedConfig == null) { // Get properties for current configuration from project file and cache it this._project.SetConfiguration(this.ConfigName, this.Platform); this._project.BuildProject.ReevaluateIfNecessary(); if (this._project.UserBuildProject != null) { this._project.UserBuildProject.ReevaluateIfNecessary(); } // Create a snapshot of the evaluated project in its current state this.currentConfig = this._project.BuildProject.CreateProjectInstance(); if (this._project.UserBuildProject != null) { this.currentUserConfig = this._project.UserBuildProject.CreateProjectInstance(); } requestedConfig = storageType == _PersistStorageType.PST_PROJECT_FILE ? currentConfig : currentUserConfig; // Restore configuration _project.SetCurrentConfiguration(); } if (requestedConfig == null) { if (storageType == _PersistStorageType.PST_PROJECT_FILE) { throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.FailedToRetrieveProperties, CultureInfo.CurrentUICulture), propertyName)); } // user build projects aren't essential return(null); } // return property asked for return(requestedConfig.GetProperty(propertyName)); }
private MSBuildExecution.ProjectPropertyInstance GetMsBuildProperty(string propertyName, bool resetCache) { if (resetCache || this.currentConfig == null) { // Get properties for current configuration from project file and cache it this.project.SetConfiguration(this.ConfigName); this.project.BuildProject.ReevaluateIfNecessary(); // Create a snapshot of the evaluated project in its current state this.currentConfig = this.project.BuildProject.CreateProjectInstance(); // Restore configuration project.SetCurrentConfiguration(); } if (this.currentConfig == null) { throw new Exception("Failed to retrieve properties"); } // return property asked for return(this.currentConfig.GetProperty(propertyName)); }
public virtual void SetConfigurationProperty(string propertyName, string propertyValue) { if (!this.project.QueryEditProjectFile(false)) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } // Старое значение строки формата: ConfigProvider.configString string condition = MakeMSBuildCondition(ConfigurationName, PlatformName); SetPropertyUnderCondition(propertyName, propertyValue, condition); // property cache will need to be updated this.currentConfig = null; // Signal the output groups that something is changed foreach (OutputGroup group in this.OutputGroups) { group.InvalidateGroup(); } this.project.SetProjectFileDirty(true); return; }
public virtual void SetConfigurationProperty(string propertyName, string propertyValue) { if (!this.project.QueryEditProjectFile(false)) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } string condition = String.Format(CultureInfo.InvariantCulture, ConfigProvider.configString, this.ConfigName); SetPropertyUnderCondition(propertyName, propertyValue, condition); // property cache will need to be updated this.currentConfig = null; // Signal the output groups that something is changed foreach (OutputGroup group in this.OutputGroups) { group.InvalidateGroup(); } this.project.SetProjectFileDirty(true); return; }
public void TestConfigChange() { UIThreadInvoker.Invoke((ThreadInvoker) delegate() { //Get the global service provider and the dte IServiceProvider sp = VsIdeTestHostContext.ServiceProvider; DTE dte = (DTE)sp.GetService(typeof(DTE)); string destination = Path.Combine(TestContext.TestDir, TestContext.TestName); ProjectNode project = Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true); EnvDTE.Property property = dte.Solution.Properties.Item("ActiveConfig"); // Now change the active config that should trigger a project config change event and the global property should be thus updated. property.Value = "Release|Any CPU"; MSBuildExecution.ProjectInstance buildProject = project.CurrentConfig; string activeConfig = null; buildProject.GlobalProperties.TryGetValue(GlobalProperty.Configuration.ToString(), out activeConfig); Assert.AreEqual("Release", activeConfig); }); }
protected bool ReadPropertyBool(MSB.Execution.ProjectInstance executedProject, string executedPropertyName, string evaluatedPropertyName) { return(ConvertToBool(ReadPropertyString(executedProject, executedPropertyName, evaluatedPropertyName))); }
protected virtual IEnumerable <MSB.Framework.ITaskItem> GetDocumentsFromModel(MSB.Execution.ProjectInstance executedProject) { return(executedProject.GetItems("Compile")); }
protected virtual IEnumerable <MSB.Framework.ITaskItem> GetMetadataReferencesFromModel(MSB.Execution.ProjectInstance executedProject) { return(executedProject.GetItems("ReferencePath")); }
private ProjectFileInfo CreateProjectFileInfo(CSharpCompilerInputs compilerInputs, MSB.Execution.ProjectInstance executedProject) { string projectDirectory = executedProject.Directory; string directorySeparator = Path.DirectorySeparatorChar.ToString(); if (!projectDirectory.EndsWith(directorySeparator, StringComparison.OrdinalIgnoreCase)) { projectDirectory += directorySeparator; } var docs = compilerInputs.Sources .Where(s => !Path.GetFileName(s.ItemSpec).StartsWith("TemporaryGeneratedFile_", StringComparison.Ordinal)) .Select(s => MakeDocumentFileInfo(projectDirectory, s)) .ToImmutableArray(); var additionalDocs = compilerInputs.AdditionalSources .Select(s => MakeDocumentFileInfo(projectDirectory, s)) .ToImmutableArray(); var outputPath = Path.Combine(this.GetOutputDirectory(), compilerInputs.OutputFileName); var assemblyName = this.GetAssemblyName(); return(new ProjectFileInfo( outputPath, assemblyName, compilerInputs.CommandLineArgs, docs, additionalDocs, this.GetProjectReferences(executedProject))); }
private void InitializeFromModel(CSharpCompilerInputs compilerInputs, MSB.Execution.ProjectInstance executedProject) { compilerInputs.BeginInitialization(); compilerInputs.SetAllowUnsafeBlocks(this.ReadPropertyBool(executedProject, "AllowUnsafeBlocks")); compilerInputs.SetApplicationConfiguration(this.ReadPropertyString(executedProject, "AppConfigForCompiler")); compilerInputs.SetBaseAddress(this.ReadPropertyString(executedProject, "BaseAddress")); compilerInputs.SetCheckForOverflowUnderflow(this.ReadPropertyBool(executedProject, "CheckForOverflowUnderflow")); compilerInputs.SetCodePage(this.ReadPropertyInt(executedProject, "CodePage")); compilerInputs.SetDebugType(this.ReadPropertyString(executedProject, "DebugType")); compilerInputs.SetDefineConstants(this.ReadPropertyString(executedProject, "DefineConstants")); compilerInputs.SetFeatures(this.ReadPropertyString(executedProject, "Features")); var delaySignProperty = this.GetProperty("DelaySign"); compilerInputs.SetDelaySign(delaySignProperty != null && !string.IsNullOrEmpty(delaySignProperty.EvaluatedValue), this.ReadPropertyBool(executedProject, "DelaySign")); compilerInputs.SetDisabledWarnings(this.ReadPropertyString(executedProject, "NoWarn")); compilerInputs.SetDocumentationFile(this.GetItemString(executedProject, "DocFileItem")); compilerInputs.SetEmitDebugInformation(this.ReadPropertyBool(executedProject, "DebugSymbols")); compilerInputs.SetErrorReport(this.ReadPropertyString(executedProject, "ErrorReport")); compilerInputs.SetFileAlignment(this.ReadPropertyInt(executedProject, "FileAlignment")); compilerInputs.SetGenerateFullPaths(this.ReadPropertyBool(executedProject, "GenerateFullPaths")); compilerInputs.SetHighEntropyVA(this.ReadPropertyBool(executedProject, "HighEntropyVA")); bool signAssembly = this.ReadPropertyBool(executedProject, "SignAssembly"); if (signAssembly) { compilerInputs.SetKeyContainer(this.ReadPropertyString(executedProject, "KeyContainerName")); compilerInputs.SetKeyFile(this.ReadPropertyString(executedProject, "KeyOriginatorFile", "AssemblyOriginatorKeyFile")); } compilerInputs.SetLangVersion(this.ReadPropertyString(executedProject, "LangVersion")); compilerInputs.SetMainEntryPoint(null, this.ReadPropertyString(executedProject, "StartupObject")); compilerInputs.SetModuleAssemblyName(this.ReadPropertyString(executedProject, "ModuleAssemblyName")); compilerInputs.SetNoStandardLib(this.ReadPropertyBool(executedProject, "NoCompilerStandardLib")); compilerInputs.SetOptimize(this.ReadPropertyBool(executedProject, "Optimize")); compilerInputs.SetOutputAssembly(this.GetItemString(executedProject, "IntermediateAssembly")); compilerInputs.SetPdbFile(this.ReadPropertyString(executedProject, "PdbFile")); if (this.ReadPropertyBool(executedProject, "Prefer32Bit")) { compilerInputs.SetPlatformWith32BitPreference(this.ReadPropertyString(executedProject, "PlatformTarget")); } else { compilerInputs.SetPlatform(this.ReadPropertyString(executedProject, "PlatformTarget")); } compilerInputs.SetSubsystemVersion(this.ReadPropertyString(executedProject, "SubsystemVersion")); compilerInputs.SetTargetType(this.ReadPropertyString(executedProject, "OutputType")); // Decode the warning options from RuleSet file prior to reading explicit settings in the project file, so that project file settings prevail for duplicates. compilerInputs.SetRuleSet(this.ReadPropertyString(executedProject, "RuleSet")); compilerInputs.SetTreatWarningsAsErrors(this.ReadPropertyBool(executedProject, "TreatWarningsAsErrors")); compilerInputs.SetWarningLevel(this.ReadPropertyInt(executedProject, "WarningLevel")); compilerInputs.SetWarningsAsErrors(this.ReadPropertyString(executedProject, "WarningsAsErrors")); compilerInputs.SetWarningsNotAsErrors(this.ReadPropertyString(executedProject, "WarningsNotAsErrors")); compilerInputs.SetReferences(this.GetMetadataReferencesFromModel(executedProject).ToArray()); compilerInputs.SetAnalyzers(this.GetAnalyzerReferencesFromModel(executedProject).ToArray()); compilerInputs.SetAdditionalFiles(this.GetAdditionalFilesFromModel(executedProject).ToArray()); compilerInputs.SetSources(this.GetDocumentsFromModel(executedProject).ToArray()); string errorMessage; int errorCode; compilerInputs.EndInitialization(out errorMessage, out errorCode); }
protected virtual IEnumerable <MSB.Framework.ITaskItem> GetAnalyzerReferencesFromModel(MSB.Execution.ProjectInstance executedProject) { return(executedProject.GetItems("Analyzer")); }
protected IEnumerable <MSB.Framework.ITaskItem> GetTaskItems(MSB.Execution.ProjectInstance executedProject, string itemType) { return(executedProject.GetItems(itemType)); }
internal BuildResult(MSB.Execution.BuildResult result, MSB.Execution.ProjectInstance instance) { this.Result = result; this.Instance = instance; }
protected TEnum?ReadPropertyEnum <TEnum>(MSB.Execution.ProjectInstance executedProject, string executedPropertyName, string evaluatedPropertyName) where TEnum : struct { return(ConvertToEnum <TEnum>(ReadPropertyString(executedProject, executedPropertyName, evaluatedPropertyName))); }
protected ulong ReadPropertyULong(MSB.Execution.ProjectInstance executedProject, string executedPropertyName, string evaluatedPropertyName) { return(ConvertToULong(this.ReadPropertyString(executedProject, executedPropertyName, evaluatedPropertyName))); }
protected ulong ReadPropertyULong(MSB.Execution.ProjectInstance executedProject, string propertyName) { return(ConvertToULong(ReadPropertyString(executedProject, propertyName))); }
protected string ReadPropertyString(MSB.Execution.ProjectInstance executedProject, string propertyName) { return(this.ReadPropertyString(executedProject, propertyName, propertyName)); }
protected int ReadPropertyInt(MSB.Execution.ProjectInstance executedProject, string executedPropertyName, string evaluatedPropertyName) { return(ConvertToInt(ReadPropertyString(executedProject, executedPropertyName, evaluatedPropertyName))); }
protected virtual IEnumerable <MSB.Framework.ITaskItem> GetAdditionalFilesFromModel(MSB.Execution.ProjectInstance executedProject) { return(executedProject.GetItems("AdditionalFiles")); }