public CSharpProject(Solution solution, string title, string fileName) { this.Solution = solution; this.Title = title; this.FileName = fileName; var p = new Microsoft.Build.Evaluation.Project(fileName); this.AssemblyName = p.GetPropertyValue("AssemblyName"); this.CompilerSettings.AllowUnsafeBlocks = GetBoolProperty(p, "AllowUnsafeBlocks") ?? false; this.CompilerSettings.CheckForOverflow = GetBoolProperty(p, "CheckForOverflowUnderflow") ?? false; foreach (string symbol in p.GetPropertyValue("DefineConstants").Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries)) { this.CompilerSettings.ConditionalSymbols.Add(symbol.Trim()); } foreach (var item in p.GetItems("Compile")) { Files.Add(new CSharpFile(this, Path.Combine(p.DirectoryPath, item.EvaluatedInclude))); } List<IAssemblyReference> references = new List<IAssemblyReference>(); string mscorlib = FindAssembly(Program.AssemblySearchPaths, "mscorlib"); if (mscorlib != null) { references.Add(Program.LoadAssembly(mscorlib)); } else { Console.WriteLine("Could not find mscorlib"); } bool hasSystemCore = false; foreach (var item in p.GetItems("Reference")) { string assemblyFileName = null; if (item.HasMetadata("HintPath")) { assemblyFileName = Path.Combine(p.DirectoryPath, item.GetMetadataValue("HintPath")); if (!File.Exists(assemblyFileName)) assemblyFileName = null; } if (assemblyFileName == null) { assemblyFileName = FindAssembly(Program.AssemblySearchPaths, item.EvaluatedInclude); } if (assemblyFileName != null) { if (Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase)) hasSystemCore = true; references.Add(Program.LoadAssembly(assemblyFileName)); } else { Console.WriteLine("Could not find referenced assembly " + item.EvaluatedInclude); } } if (!hasSystemCore && FindAssembly(Program.AssemblySearchPaths, "System.Core") != null) references.Add(Program.LoadAssembly(FindAssembly(Program.AssemblySearchPaths, "System.Core"))); foreach (var item in p.GetItems("ProjectReference")) { references.Add(new ProjectReference(solution, item.GetMetadataValue("Name"))); } this.ProjectContent = new CSharpProjectContent() .SetAssemblyName(this.AssemblyName) .SetCompilerSettings(this.CompilerSettings) .AddAssemblyReferences(references) .UpdateProjectContent(null, Files.Select(f => f.ParsedFile)); }
private static void AddEnsureImportedTarget(MsBuildProject buildProject, string targetsPath) { // get the target var targetElement = buildProject.Xml.Targets.FirstOrDefault( target => target.Name.Equals(targetName, StringComparison.OrdinalIgnoreCase)); // if the target does not exist, create the target if (targetElement == null) { targetElement = buildProject.Xml.AddTarget(targetName); // PrepareForBuild is used here because BeforeBuild does not work for VC++ projects. targetElement.BeforeTargets = "PrepareForBuild"; var propertyGroup = targetElement.AddPropertyGroup(); propertyGroup.AddProperty("ErrorText", CommonResources.EnsureImportedMessage); } var errorTask = targetElement.AddTask("Error"); errorTask.Condition = "!Exists('" + targetsPath + "')"; var errorText = string.Format( CultureInfo.InvariantCulture, @"$([System.String]::Format('$(ErrorText)', '{0}'))", targetsPath); errorTask.SetParameter("Text", errorText); }
public BasicTests(ITestOutputHelper logger) { this.logger = logger; this.nuproj = Assets.FromTemplate() .AssignNuProjDirectory() .ToProject(); }
public static ActionsModule CreateFromProject(string projectFile, string outputFile, LightningDevelopmentHandle lightningDevelopmentHandle) { var engine = new Microsoft.Build.Evaluation.Project(projectFile); engine.Build(); return CreateFromDll(outputFile, lightningDevelopmentHandle); }
public void AddNewErrorWarningMessageElement() { MockLogger logger = new MockLogger(); /** * <Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`> * <Target Name=`Build`> * </Target> * </Project */ ProjectRootElement projectXml = ProjectRootElement.Create(); ProjectTargetElement target = projectXml.AddTarget("Build"); projectXml.DefaultTargets = "Build"; projectXml.ToolsVersion = ObjectModelHelpers.MSBuildDefaultToolsVersion; SolutionProjectGenerator.AddErrorWarningMessageElement(target, XMakeElements.message, true, "SolutionVenusProjectNoClean"); SolutionProjectGenerator.AddErrorWarningMessageElement(target, XMakeElements.warning, true, "SolutionParseUnknownProjectType", "proj1.csproj"); SolutionProjectGenerator.AddErrorWarningMessageElement(target, XMakeElements.error, true, "SolutionInvalidSolutionConfiguration"); Project project = new Project(projectXml); project.Build(logger); string code = null; string keyword = null; string text = ResourceUtilities.FormatResourceString(out code, out keyword, "SolutionParseUnknownProjectType", "proj1.csproj"); // check the error event Assert.AreEqual(1, logger.Warnings.Count); BuildWarningEventArgs warning = logger.Warnings[0]; Assert.AreEqual(text, warning.Message); Assert.AreEqual(code, warning.Code); Assert.AreEqual(keyword, warning.HelpKeyword); code = null; keyword = null; text = ResourceUtilities.FormatResourceString(out code, out keyword, "SolutionInvalidSolutionConfiguration"); // check the warning event Assert.AreEqual(1, logger.Errors.Count); BuildErrorEventArgs error = logger.Errors[0]; Assert.AreEqual(text, error.Message); Assert.AreEqual(code, error.Code); Assert.AreEqual(keyword, error.HelpKeyword); code = null; keyword = null; text = ResourceUtilities.FormatResourceString(out code, out keyword, "SolutionVenusProjectNoClean"); // check the message event Assert.IsTrue(logger.FullLog.Contains(text), "Log should contain the regular message"); }
private static void AddFeatureFileLinkToIntelliSenseProject(string featureFilePath, string featureDir, string pathToIntelliSenseProject) { _csProj = _csProj ?? GetUnloadedProject(pathToIntelliSenseProject); featureFilePath = MakeLinkRelativeToIntelliSenseProject(featureFilePath, featureDir); var featureFileLink = featureFilePath.Replace(@"..\", string.Empty); if (!_csProj.Items.Any(item => item.GetMetadataValue("Link") == featureFileLink)) { _csProj.AddItem("None", featureFilePath, new Dictionary<string, string> { { "Link", featureFileLink } }); _isDirtyCsProj = true; } }
/// <summary> /// Builds this project, using the default targets and the given loggers. /// </summary> /// <param name="loggers">An enumerator over all loggers to be used during the build.</param> /// <returns> /// Returns true on success; false otherwise. /// </returns> public bool Build(IEnumerable<ILogger> loggers) { var result = false; this.SwapMSBuildTasks(); using (var reader = this.Document.CreateReader()) { reader.MoveToContent(); var innerProject = new Microsoft.Build.Evaluation.Project(reader); result = innerProject.Build(loggers.Prepend(this.Logger)); reader.Close(); } return result; }
private static void AddFilesToCppProject(string pathToFile, string featureDir, string pathToCppProject) { _cppProj = _cppProj ?? GetUnloadedProject(pathToCppProject); pathToFile = MakeFeatureDirRelativeToCppProject(pathToFile, featureDir); string type = CppFileType(pathToFile); if (!_cppProj.GetItems(type).Any(item => item.UnevaluatedInclude == pathToFile)) { _cppProj.AddItem(type, pathToFile); _isDirtyCppProj = true; } }
/// <summary> /// Toes the hierarchy. /// </summary> /// <param name="project">The project.</param> /// <returns></returns> public static IVsHierarchy ToHierarchy(EnvDTE.Project project) { if (project == null) throw new ArgumentNullException("project"); // DTE does not expose the project GUID that exists at in the msbuild project file. Microsoft.Build.Evaluation.Project msproject = new Microsoft.Build.Evaluation.Project(); msproject.FullPath = project.FileName; string guid = msproject.GetPropertyValue("ProjectGuid"); IServiceProvider serviceProvider = new ServiceProvider(project.DTE as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); return VsShellUtilities.GetHierarchy(serviceProvider, new Guid(guid)); }
/// <summary> /// Removes the Import element from the project file. /// </summary> /// <param name="project">The project file.</param> /// <param name="targetsPath">The path to the imported file.</param> public static void RemoveImportStatement(MsBuildProject project, string targetsPath) { if (project.Xml.Imports != null) { // search for this import statement and remove it var importElement = project.Xml.Imports.FirstOrDefault( import => targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase)); if (importElement != null) { importElement.Parent.RemoveChild(importElement); NuGet.MSBuildProjectUtility.RemoveEnsureImportedTarget(project, targetsPath); project.ReevaluateIfNecessary(); } } }
private static void ConfigProjectImport(Project project, string targetRelativePath, string configTransformTargetFile) { // clear out any existing value var importPathMSBuildProperty = "ConfigTransformTargetPath"; var msbuildProp = project.Xml.Properties.Where(x => x.Name == importPathMSBuildProperty).ToArray(); msbuildProp.Delete(); // creates a property to store the target file path var importPath = $"$({importPathMSBuildProperty})\\{configTransformTargetFile}"; project.Xml.AddProperty(importPathMSBuildProperty, targetRelativePath); // create import element with exists condition and add as last project import var importXmlElement = project.Xml.CreateImportElement(importPath); importXmlElement.Condition = $"Exists('{importPath}')"; project.Xml.InsertAfterChild(importXmlElement, project.Xml.Imports.Last()); }
public CSharpProject(Solution solution, string title, string fileName) { // Normalize the file name fileName = Path.GetFullPath(fileName); this.Solution = solution; this.Title = title; this.FileName = fileName; // Use MSBuild to open the .csproj var msbuildProject = new Microsoft.Build.Evaluation.Project(fileName); // Figure out some compiler settings this.AssemblyName = msbuildProject.GetPropertyValue("AssemblyName"); this.CompilerSettings.AllowUnsafeBlocks = GetBoolProperty(msbuildProject, "AllowUnsafeBlocks") ?? false; this.CompilerSettings.CheckForOverflow = GetBoolProperty(msbuildProject, "CheckForOverflowUnderflow") ?? false; string defineConstants = msbuildProject.GetPropertyValue("DefineConstants"); foreach (string symbol in defineConstants.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries)) this.CompilerSettings.ConditionalSymbols.Add(symbol.Trim()); // Initialize the unresolved type system IProjectContent pc = new CSharpProjectContent(); pc = pc.SetAssemblyName(this.AssemblyName); pc = pc.SetProjectFileName(fileName); pc = pc.SetCompilerSettings(this.CompilerSettings); // Parse the C# code files foreach (var item in msbuildProject.GetItems("Compile")) { var file = new CSharpFile(this, Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude)); Files.Add(file); } // Add parsed files to the type system pc = pc.AddOrUpdateFiles(Files.Select(f => f.UnresolvedTypeSystemForFile)); // Add referenced assemblies: foreach (string assemblyFile in ResolveAssemblyReferences(msbuildProject)) { IUnresolvedAssembly assembly = solution.LoadAssembly(assemblyFile); pc = pc.AddAssemblyReferences(new [] { assembly }); } // Add project references: foreach (var item in msbuildProject.GetItems("ProjectReference")) { string referencedFileName = Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude); // Normalize the path; this is required to match the name with the referenced project's file name referencedFileName = Path.GetFullPath(referencedFileName); pc = pc.AddAssemblyReferences(new[] { new ProjectReference(referencedFileName) }); } this.ProjectContent = pc; }
/// <summary> /// Adds an Import element to this project file if it doesn't already exist. /// </summary> /// <param name="project">The project file.</param> /// <param name="targetsPath">The path to the imported file.</param> /// <param name="location">The location where the Import is added.</param> public static void AddImportStatement(MsBuildProject project, string targetsPath, ProjectImportLocation location) { if (project.Xml.Imports == null || project.Xml.Imports.All(import => !targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase))) { ProjectImportElement pie = project.Xml.AddImport(targetsPath); pie.Condition = "Exists('" + targetsPath + "')"; if (location == ProjectImportLocation.Top) { // There's no public constructor to create a ProjectImportElement directly. // So we have to cheat by adding Import at the end, then remove it and insert at the beginning pie.Parent.RemoveChild(pie); project.Xml.InsertBeforeChild(pie, project.Xml.FirstChild); } NuGet.MSBuildProjectUtility.AddEnsureImportedTarget(project, targetsPath); project.ReevaluateIfNecessary(); } }
public void GetProject(string ProjectPath) { try { if (Project == null) { if (string.IsNullOrEmpty(ProjectPath)) { throw new ArgumentNullException("Project Path is not defined"); } Project = new Microsoft.Build.Evaluation.Project(ProjectPath, null, "14.0"); var zz = Project.ToolsVersion; } } catch (Exception ex) { throw ex; } }
private void StyleCopCoreAddSettingsPages(object sender, AddSettingsPagesEventArgs e) { Param.Ignore(sender); Param.AssertNotNull(e, "e"); Project project = ProjectUtilities.GetActiveProject(); string fullName = ProjectUtilities.GetProjectFullName(project); if (string.IsNullOrEmpty(fullName)) { return; } project.Save(); var proj = new Microsoft.Build.Evaluation.Project( project.FullName, null, null, new Microsoft.Build.Evaluation.ProjectCollection()); e.Add(new BuildIntegrationOptions(proj)); }
//--------------------------------------------------------------------------- public bool AddFile(string source, string destination) { try { if (!string.IsNullOrEmpty(source) && !source.Equals(destination)) { File.Copy(source, Path.Combine(RootPath, destination)); } string path = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"..\..\..\", "EvershockGame/EvershockGame.csproj")); var project = new Microsoft.Build.Evaluation.Project(@path); project.AddItem("Content", string.Format(@"Content\{0}", destination.Replace('/', '\\')), new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>("CopyToOutputDirectory", "PreserveNewest") }); project.Save(); return(true); } catch (Exception e) { } return(false); }
public static bool UpgradeGeneratedItems(Microsoft.Build.Evaluation.Project project, string outputDir, string ext, string itemType) { string projectDir = Path.GetDirectoryName(project.FullPath); bool modified = false; var sliceItems = project.AllEvaluatedItems.Where(item => item.ItemType.Equals("SliceCompile")); foreach (var sliceItem in sliceItems) { var generatedPath = FileUtil.RelativePath(projectDir, Path.Combine(outputDir, string.Format("{0}.{1}", Path.GetFileNameWithoutExtension(sliceItem.EvaluatedInclude), ext))); var generated = project.AllEvaluatedItems.FirstOrDefault( item => item.ItemType.Equals(itemType) && item.EvaluatedInclude.Equals(generatedPath)); if (generated != null) { generated.SetMetadataValue("SliceCompileSource", sliceItem.EvaluatedInclude); modified = true; } } return(modified); }
private void AddFileToProjest(string projectPath, string filePath) { Project pr; if (OpenProjectsMap.ContainsKey(projectPath)) { pr = OpenProjectsMap[projectPath]; } else { pr = new Project(projectPath); OpenProjectsMap.Add(projectPath, pr); } pr.ReevaluateIfNecessary(); pr.DisableMarkDirty = true; pr.AddItem("Compile", filePath); pr.Save(); }
public void IncludeProject() { var projFile = new Microsoft.Build.Evaluation.Project(ProjFile); foreach (string file in System.IO.Directory.GetFiles(Directory, "*.feature", SearchOption.AllDirectories)) { var fileName = Path.GetFileName(file); var relativeFilePath = MakeRelative(file, ProjFile).Replace("/", "\\"); var projectItem = projFile.Items.FirstOrDefault(i => i.EvaluatedInclude == relativeFilePath); if (projectItem == null) { projFile.AddItem("None", relativeFilePath, new[] { new KeyValuePair <string, string>("Generator", "SpecFlowSingleFileGenerator"), new KeyValuePair <string, string>("LastGenOutput", $"{fileName}.cs") }); } } projFile.Save(); }
private static void SetTargetFrameworkIfNeeded(MSB.Evaluation.Project evaluatedProject) { var targetFramework = evaluatedProject.GetPropertyValue(PropertyNames.TargetFramework); var targetFrameworks = PropertyConverter.SplitList(evaluatedProject.GetPropertyValue(PropertyNames.TargetFrameworks), ';'); // If the project supports multiple target frameworks and specific framework isn't // selected, we must pick one before execution. Otherwise, the ResolveReferences // target might not be available to us. if (string.IsNullOrWhiteSpace(targetFramework) && targetFrameworks.Length > 0) { // For now, we'll just pick the first target framework. Eventually, we'll need to // do better and potentially allow OmniSharp hosts to select a target framework. targetFramework = targetFrameworks[0]; evaluatedProject.SetProperty(PropertyNames.TargetFramework, targetFramework); } else if (!string.IsNullOrWhiteSpace(targetFramework) && targetFrameworks.Length == 0) { targetFrameworks = ImmutableArray.Create(targetFramework); } }
private void AddSolutionDirProperty(MsBuildProject buildProject) { const string solutiondir = "SolutionDir"; if (buildProject.Xml.Properties == null || buildProject.Xml.Properties.All(p => p.Name != solutiondir)) { string relativeSolutionPath = PathUtility.GetRelativePath( buildProject.FullPath, PathUtility.EnsureTrailingSlash(_solutionManager.SolutionDirectory)); relativeSolutionPath = PathUtility.EnsureTrailingSlash(relativeSolutionPath); var solutionDirProperty = buildProject.Xml.AddProperty(solutiondir, relativeSolutionPath); solutionDirProperty.Condition = String.Format( CultureInfo.InvariantCulture, @"$({0}) == '' Or $({0}) == '*Undefined*'", solutiondir); } }
private void EnablePackageRestore(Project project) { if (project.IsWebSite()) { // Can't do anything with Website // Also, the Javascript Metro project system has some weird bugs // that cause havoc with the package restore mechanism return; } if (project.IsJavaScriptProject()) { EnablePackageRestoreForJavaScriptProject(project); } else { MsBuildProject buildProject = project.AsMSBuildProject(); EnablePackageRestore(project, buildProject, saveProjectWhenDone: true); } }
public void ExecuteWithoutHost() { ScannerTask target = new ScannerTask(); // Create the term tables and target files. string termFile1 = Utilities.CreateTempFile(CreateTermTableXml("countries", 2, "Geopolitical", "comment")); string termFile2 = Utilities.CreateTempFile(CreateTermTableXml("shoot", 3, "Profanity", "comment")); string scanFile1 = Utilities.CreateTempTxtFile("the word 'countries' should produce a hit"); string scanFile2 = Utilities.CreateTempTxtFile("the word 'shoot' should produce a hit"); // Create the project that will execute the task. Microsoft.Build.Evaluation.Project project = Utilities.SetupMSBuildProject(new string[] { scanFile1, scanFile2 }, new string[] { termFile1, termFile2 }); // Set up a custom logger to capture the output. MockLogger logger = new MockLogger(); project.ProjectCollection.RegisterLogger(logger); int errors = 0; int warnings = 0; int messages = 0; logger.OnError += delegate(object sender, BuildErrorEventArgs args) { ++errors; }; logger.OnWarning += delegate(object sender, BuildWarningEventArgs args) { ++warnings; }; logger.OnMessage += delegate(object sender, BuildMessageEventArgs args) { ++messages; }; project.Build("AfterBuild"); Assert.AreEqual(0, errors, "Build did not log expected number of errors."); Assert.AreEqual(2, warnings, "Build did not log expected number of warnings."); Assert.AreEqual(2, messages, "Build did not log expected number of messages."); }
public void FileProperties() { using (PackageTestEnvironment testEnv = new PackageTestEnvironment()) { PropertyInfo buildProjectInfo = typeof(VisualStudio.Project.ProjectNode).GetProperty("BuildProject", BindingFlags.Instance | BindingFlags.NonPublic); Microsoft.Build.Evaluation.Project buildProject = buildProjectInfo.GetValue(testEnv.Project, new object[0]) as Microsoft.Build.Evaluation.Project; // Add a node to the project map so it can be resolved IEnumerable <Microsoft.Build.Evaluation.ProjectItem> itemGroup = buildProject.GetItems("Compile"); Microsoft.Build.Evaluation.ProjectItem item = null; foreach (Microsoft.Build.Evaluation.ProjectItem currentItem in itemGroup) { if (currentItem.EvaluatedInclude == "OtherFile.cs") { item = currentItem; break; } } VisualStudio.Project.FileNode node = new VisualStudio.Project.FileNode(testEnv.Project, testEnv.Project.GetProjectElement(item)); MethodInfo itemMapGetter = typeof(VisualStudio.Project.ProjectNode).GetProperty("ItemIdMap", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(true); Microsoft.VisualStudio.Shell.EventSinkCollection itemMap = (Microsoft.VisualStudio.Shell.EventSinkCollection)itemMapGetter.Invoke(testEnv.Project, new object[0]); uint itemID = itemMap.Add(node); IVsBuildPropertyStorage buildProperty = testEnv.Project as IVsBuildPropertyStorage; Assert.IsNotNull(buildProperty, "Project does not implements IVsBuildPropertyStorage."); // Get string propertyName = "Metadata"; string value = null; int hr = buildProperty.GetItemAttribute(itemID, propertyName, out value); Assert.AreEqual <int>(VSConstants.S_OK, hr, "GetItemAttribute failed"); Assert.AreEqual("OtherFileProperty", value); // Set (with get to confirm) string newValue = "UpdatedFileProperty"; hr = buildProperty.SetItemAttribute(itemID, propertyName, newValue); Assert.AreEqual <int>(VSConstants.S_OK, hr, "SetPropertyValue failed"); hr = buildProperty.GetItemAttribute(itemID, propertyName, out value); Assert.AreEqual <int>(VSConstants.S_OK, hr, "GetItemAttribute failed"); Assert.AreEqual(newValue, value); } }
static bool?GetBoolProperty(Microsoft.Build.Evaluation.Project p, string propertyName) { if (FixUtil.Instance.NeedFix("CSharpProject.GetBoolProperty")) { string strParameter = string.Format("CSharpProject,GetBoolProperty,{0},{1},{2}", typeof(object), typeof(Microsoft.Build.Evaluation.Project), typeof(string)); FixUtil.Instance.Fix(strParameter, null, p, propertyName); return; } string val = p.GetPropertyValue(propertyName); bool result; if (bool.TryParse(val, out result)) { return(result); } else { return(null); } }
/// <summary> /// The resolved type system for this project. /// This field is initialized once all projects have been loaded (in Solution constructor). /// </summary> public CSharpProject(Solution solution, string title, string fileName) { // Normalize the file name fileName = Path.GetFullPath(fileName); this.Solution = solution; this.Title = title; this.FileName = fileName; // Use MSBuild to open the .csproj var msbuildProject = new Microsoft.Build.Evaluation.Project(fileName); // Figure out some compiler settings this.AssemblyName = msbuildProject.GetPropertyValue("AssemblyName"); // Parse the C# code files foreach (var item in msbuildProject.GetItems("Compile")) { var file = new CSharpFile(this, Path.Combine(msbuildProject.DirectoryPath, item.EvaluatedInclude)); Files.Add(file); } }
private void EnsureImport(Microsoft.Build.Evaluation.Project project, string importProjectPath) { // Ensure import is present, replace existing if found. var fileName = Path.GetFileName(importProjectPath); var existingImport = project.Xml.Imports.Cast <ProjectImportElement>().FirstOrDefault(i => i.Project.EndsWith(fileName)); if (existingImport != null) { _Logger.LogInfo(string.Format("The existing import will be upgraded for: {0}", fileName)); project.Xml.RemoveChild(existingImport); } var projectUri = new Uri(string.Format("file://{0}", project.FullPath)); var importFileUri = new Uri(string.Format("file://{0}", importProjectPath)); var relativeImportFile = projectUri.MakeRelativeUri(importFileUri).ToString().Replace('/', '\\'); project.Xml.AddImport(relativeImportFile); _Logger.LogInfo(string.Format("Successfully imported: {0}", relativeImportFile)); }
void SetCompilerSettings(Microsoft.Build.Evaluation.Project p) { CompilerSettings = new CompilerSettings { AllowUnsafeBlocks = GetBoolProperty(p, "AllowUnsafeBlocks") ?? false, CheckForOverflow = GetBoolProperty(p, "CheckForOverflowUnderflow") ?? false }; string[] defines = p.GetPropertyValue("DefineConstants") .Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries); foreach (string define in defines) { CompilerSettings.ConditionalSymbols.Add(define); } var config = ConfigurationLoader.Config; foreach (var define in config.Defines) { CompilerSettings.ConditionalSymbols.Add(define); } }
private static async Task DoWorkInWriterLockInternal(Project project, IVsHierarchy hierarchy, Action <MsBuildProject> action) { UnconfiguredProject unconfiguredProject = GetUnconfiguredProject((IVsProject)hierarchy); if (unconfiguredProject != null) { var service = unconfiguredProject.ProjectService.Services.ProjectLockService; if (service != null) { // WriteLockAsync will move us to a background thread. using (ProjectWriteLockReleaser x = await service.WriteLockAsync()) { await x.CheckoutAsync(unconfiguredProject.FullPath); ConfiguredProject configuredProject = await unconfiguredProject.GetSuggestedConfiguredProjectAsync(); MsBuildProject buildProject = await x.GetProjectAsync(configuredProject); if (buildProject != null) { action(buildProject); } await x.ReleaseAsync(); } // perform the save synchronously await Task.Run(() => { // move to the UI thread for the rest of this method unconfiguredProject.ProjectService.Services.ThreadingPolicy.SwitchToUIThread(); var fileSystem = new PhysicalFileSystem(@"c:\"); fileSystem.MakeFileWritable(project.FullName); project.Save(); } ); } } }
public virtual void RunFinished() { try { var proj = item.ContainingProject; var dte = item.DTE; //foreach (var x in proj.Properties.OfType<Property>()) System.Diagnostics.Debugger.Log(1, "Debug", x.Name + "\n"); CopyBin(); ConfigureProject(proj); CopyDemo(); proj.Save(); dte.ExecuteCommand("File.SaveAll", string.Empty); var filename = proj.FullName; var bproj = new Microsoft.Build.Evaluation.Project(filename); var imppath = Path.Combine(MSBuildExtensionsPath, target); if (bproj.Imports.Any(imp => imp.ImportedProject.FullPath == imppath)) { return; // import is already there, so no need to modify project any further. } ModifyWebConfig(); // select project string solutionName = Path.GetFileNameWithoutExtension(dte.Solution.FullName); dte.Windows.Item(EnvDTE.Constants.vsWindowKindSolutionExplorer).Activate(); ((EnvDTE80.DTE2)dte).ToolWindows.SolutionExplorer.GetItem(solutionName + @"\" + proj.Name).Select(vsUISelectionType.vsUISelectionTypeSelect); //Because modify the open *.csproj file outside of the IDE will pop up a window to let you reload the file. //IExecute Command to unload the project before modifying the *.csproj file. And reload after the *.csproj has already updated. bproj.Xml.AddImport(imppath); dte.ExecuteCommand("Project.UnloadProject", string.Empty); bproj.Save(); dte.ExecuteCommand("Project.ReloadProject", string.Empty); } catch (Exception ex) { } }
public static ProjectData Create(MSB.Evaluation.Project project) { var guid = PropertyConverter.ToGuid(project.GetPropertyValue(PropertyNames.ProjectGuid)); var name = project.GetPropertyValue(PropertyNames.ProjectName); var assemblyName = project.GetPropertyValue(PropertyNames.AssemblyName); var targetPath = project.GetPropertyValue(PropertyNames.TargetPath); var outputPath = project.GetPropertyValue(PropertyNames.OutputPath); var intermediateOutputPath = project.GetPropertyValue(PropertyNames.IntermediateOutputPath); var projectAssetsFile = project.GetPropertyValue(PropertyNames.ProjectAssetsFile); var configuration = project.GetPropertyValue(PropertyNames.Configuration); var platform = project.GetPropertyValue(PropertyNames.Platform); var defaultNamespace = project.GetPropertyValue(PropertyNames.RootNamespace); var targetFramework = new FrameworkName(project.GetPropertyValue(PropertyNames.TargetFrameworkMoniker)); var targetFrameworkValue = project.GetPropertyValue(PropertyNames.TargetFramework); var targetFrameworks = PropertyConverter.SplitList(project.GetPropertyValue(PropertyNames.TargetFrameworks), ';'); if (!string.IsNullOrWhiteSpace(targetFrameworkValue) && targetFrameworks.Length == 0) { targetFrameworks = ImmutableArray.Create(targetFrameworkValue); } var languageVersion = PropertyConverter.ToLanguageVersion(project.GetPropertyValue(PropertyNames.LangVersion)); var allowUnsafeCode = PropertyConverter.ToBoolean(project.GetPropertyValue(PropertyNames.AllowUnsafeBlocks), defaultValue: false); var checkForOverflowUnderflow = PropertyConverter.ToBoolean(project.GetPropertyValue(PropertyNames.CheckForOverflowUnderflow), defaultValue: false); var outputKind = PropertyConverter.ToOutputKind(project.GetPropertyValue(PropertyNames.OutputType)); var nullableContextOptions = PropertyConverter.ToNullableContextOptions(project.GetPropertyValue(PropertyNames.Nullable)); var documentationFile = project.GetPropertyValue(PropertyNames.DocumentationFile); var preprocessorSymbolNames = PropertyConverter.ToPreprocessorSymbolNames(project.GetPropertyValue(PropertyNames.DefineConstants)); var suppressedDiagnosticIds = PropertyConverter.ToSuppressedDiagnosticIds(project.GetPropertyValue(PropertyNames.NoWarn)); var signAssembly = PropertyConverter.ToBoolean(project.GetPropertyValue(PropertyNames.SignAssembly), defaultValue: false); var assemblyOriginatorKeyFile = project.GetPropertyValue(PropertyNames.AssemblyOriginatorKeyFile); var treatWarningsAsErrors = PropertyConverter.ToBoolean(project.GetPropertyValue(PropertyNames.TreatWarningsAsErrors), defaultValue: false); return(new ProjectData( guid, name, assemblyName, targetPath, outputPath, intermediateOutputPath, projectAssetsFile, configuration, platform, targetFramework, targetFrameworks, outputKind, languageVersion, nullableContextOptions, allowUnsafeCode, checkForOverflowUnderflow, documentationFile, preprocessorSymbolNames, suppressedDiagnosticIds, signAssembly, assemblyOriginatorKeyFile, treatWarningsAsErrors, defaultNamespace, ruleset: null)); }
private static CompilationOptions CreateCompilationOptions(Microsoft.Build.Evaluation.Project project, string languageName) { var outputType = project.GetPropertyValue("OutputType"); OutputKind?kind = null; switch (outputType) { case "Library": kind = OutputKind.DynamicallyLinkedLibrary; break; case "Exe": kind = OutputKind.ConsoleApplication; break; case "Module": kind = OutputKind.NetModule; break; case "Winexe": kind = OutputKind.WindowsApplication; break; } if (kind.HasValue) { if (languageName == LanguageNames.CSharp) { return(new CSharpCompilationOptions(kind.Value)); } if (languageName == LanguageNames.VisualBasic) { return(new VisualBasicCompilationOptions(kind.Value)); } } return(null); }
internal static void Build(string Proj) { #if(FRAMEWORK40) var prj = new Microsoft.Build.Evaluation.Project(Proj); try { #else Microsoft.Build.BuildEngine.Project prj = new Microsoft.Build.BuildEngine.Project(); prj.Load(Proj); #endif prj.SetProperty("DefaultTargets", "Build"); prj.SetProperty("Configuration", "Debug"); if (!prj.Build()) throw new Exception("Error building project: " + Proj + "\n"); #if(FRAMEWORK40) } finally { Microsoft.Build.Evaluation.ProjectCollection.GlobalProjectCollection.UnloadProject(prj); } #endif }
private Configuration ImportConfiguration(Microsoft.Build.Evaluation.Project msbuildProject) { Configuration config = new Configuration() { Name = "Release" }; var files = msbuildProject.GetItems("ClCompile"); config.Defines = ImportMetaData("PreprocessorDefinitions", files); config.Includes = ImportMetaData("AdditionalIncludeDirectories", files).ConvertAll(i => i); foreach (var file in files) { if (file.DirectMetadata.FirstOrDefault(m => m.Name == "PrecompiledHeader") != null) { config.PrecompiledHeader = Path.GetFullPath(Path.Combine(msbuildProject.DirectoryPath, file.EvaluatedInclude)); } } return(config); }
private static void MigrateRuntimes(PackageSpec packageSpec, Microsoft.Build.Evaluation.Project buildProject) { ThreadHelper.ThrowIfNotOnUIThread(); var runtimes = packageSpec.RuntimeGraph.Runtimes; var supports = packageSpec.RuntimeGraph.Supports; var runtimeIdentifiers = new List <string>(); var runtimeSupports = new List <string>(); if (runtimes != null && runtimes.Count > 0) { runtimeIdentifiers.AddRange(runtimes.Keys); } if (supports != null && supports.Count > 0) { runtimeSupports.AddRange(supports.Keys); } var union = string.Join(";", runtimeIdentifiers.Union(runtimeSupports)); buildProject.SetProperty("RuntimeIdentifiers", union); }
private IList <string> LoadConfigurationsWithMicrosoftBuild() { Microsoft.Build.Evaluation.Project p = null; try { p = Microsoft.Build.Evaluation.ProjectCollection.GlobalProjectCollection.LoadProject(_filepath); var configurations = p.ConditionedProperties["Configuration"]; var platforms = p.ConditionedProperties["Platform"]; return(configurations.SelectMany(configuration => platforms.Select(platform => configuration + "|" + platform)).ToList()); } catch (Exception ex) { _errors.Add(ex.Message); return(new string[0]); } finally { if (p != null) { try { Microsoft.Build.Evaluation.ProjectCollection.GlobalProjectCollection.UnloadProject(p); // ReSharper disable once EmptyGeneralCatchClause } catch { } } } }
void AddProjectReferences(Microsoft.Build.Evaluation.Project p) { foreach (Microsoft.Build.Evaluation.ProjectItem item in p.GetItems("ProjectReference")) { var projectName = item.HasMetadata("Name") ? item.GetMetadataValue("Name") : Path.GetFileNameWithoutExtension(item.EvaluatedInclude); var projVal = item.GetMetadataValue("Project"); if (projVal == null) { continue; } var referenceGuid = Guid.Parse(projVal); if (referenceGuid == null) { continue; } _logger.Debug("Adding project reference {0}, {1}", projectName, referenceGuid); AddReference(new ProjectReference(_solution, projectName, referenceGuid)); } }
public void FileProperties() { using (PackageTestEnvironment testEnv = new PackageTestEnvironment()) { Microsoft.Build.Evaluation.Project buildProject = testEnv.Project.BuildProject; // Add a node to the project map so it can be resolved IEnumerable <Microsoft.Build.Evaluation.ProjectItem> itemGroup = buildProject.GetItems("Compile"); Microsoft.Build.Evaluation.ProjectItem item = null; foreach (Microsoft.Build.Evaluation.ProjectItem currentItem in itemGroup) { if (currentItem.EvaluatedInclude == "OtherFile.cs") { item = currentItem; break; } } VisualStudio.Project.FileNode node = new VisualStudio.Project.FileNode(testEnv.Project, testEnv.Project.GetProjectElement(item)); uint itemID = node.Id; IVsBuildPropertyStorage buildProperty = testEnv.Project as IVsBuildPropertyStorage; Assert.IsNotNull(buildProperty, "Project does not implements IVsBuildPropertyStorage."); // Get string propertyName = "Metadata"; string value = null; int hr = buildProperty.GetItemAttribute(itemID, propertyName, out value); Assert.AreEqual <int>(VSConstants.S_OK, hr, "GetItemAttribute failed"); Assert.AreEqual("OtherFileProperty", value); // Set (with get to confirm) string newValue = "UpdatedFileProperty"; hr = buildProperty.SetItemAttribute(itemID, propertyName, newValue); Assert.AreEqual <int>(VSConstants.S_OK, hr, "SetPropertyValue failed"); hr = buildProperty.GetItemAttribute(itemID, propertyName, out value); Assert.AreEqual <int>(VSConstants.S_OK, hr, "GetItemAttribute failed"); Assert.AreEqual(newValue, value); } }
public ArrayList GetReferences(string name) { ArrayList L = new ArrayList(); Microsoft.Build.Evaluation.Project pc = null; try { pc = new Microsoft.Build.Evaluation.Project(FileName); } catch (Exception e) { } if (pc == null) { return(L); } string folder = Path.GetDirectoryName(FileName); ICollection <Microsoft.Build.Evaluation.ProjectItem> s = pc.GetItems(name); foreach (Microsoft.Build.Evaluation.ProjectItem p in s) { string file = Path.GetFullPath(folder + "\\" + p.EvaluatedInclude); string project = Path.GetFileNameWithoutExtension(file); file = p.EvaluatedInclude; L.Add(file); } pc.ProjectCollection.UnloadAllProjects(); return(L); }
static bool TryLoadProjectFromCsproj(string csprojFullPath, out Microsoft.Build.Evaluation.Project project, out string projectName, out Context.ProjectType projectType, out Context.ProjectOutputType projectOutputType) { try { Microsoft.Build.Evaluation.ProjectCollection collection = new Microsoft.Build.Evaluation.ProjectCollection(); collection.DefaultToolsVersion = "4.0"; Microsoft.Build.Evaluation.Project theProject = collection.LoadProject(csprojFullPath); string projectTypeGuids = theProject.GetPropertyValue("ProjectTypeGuids"); //cf. https://github.com/Microsoft/visualfsharp/blob/master/vsintegration/src/FSharp.ProjectSystem.Base/Project/ProjectFactory.cs string isSilverlightApplicationString = theProject.GetPropertyValue("SilverlightApplication"); // Get the project name: projectName = System.IO.Path.GetFileNameWithoutExtension(csprojFullPath); // Get the Project Type: projectType = GetProjectType(projectTypeGuids); // Get the project Output Type: Func <string, string> functionToGetAProjectProperty = (string propertyName) => { return(theProject.GetPropertyValue(propertyName)); }; projectOutputType = GetProjectOutputType(projectType, functionToGetAProjectProperty, functionToGetAProjectProperty); // Return the project itself as well: project = theProject; return(true); } catch (Exception ex) { MessageBox.Show(ex.ToString()); project = null; projectName = null; projectType = Context.ProjectType.Other; projectOutputType = Context.ProjectOutputType.Unknown; return(false); } }
void AddCSharpFiles(Microsoft.Build.Evaluation.Project p) { foreach (var item in p.GetItems("Compile")) { try { string path = Path.Combine(p.DirectoryPath, item.EvaluatedInclude).ForceNativePathSeparator(); if (File.Exists(path)) { string file = new FileInfo(path).FullName; _logger.Debug("Loading " + file); Files.Add(new CSharpFile(this, file)); } else { _logger.Debug("File does not exist - " + path); } } catch (NullReferenceException e) { _logger.Error(e); } } }
public ProjectLoadedEventArgs( ProjectId id, MSB.Evaluation.Project project, Guid sessionId, MSB.Execution.ProjectInstance projectInstance, ImmutableArray <MSBuildDiagnostic> diagnostics, bool isReload, bool projectIdIsDefinedInSolution, ImmutableArray <string> sourceFiles, SemanticVersion sdkVersion, IEnumerable <string> references = null) { Id = id; Project = project; SessionId = sessionId; ProjectInstance = projectInstance; Diagnostics = diagnostics; IsReload = isReload; ProjectIdIsDefinedInSolution = projectIdIsDefinedInSolution; References = references; SourceFiles = sourceFiles; SdkVersion = sdkVersion; }
public void ChangeSolution() { Microsoft.Build.Evaluation.Project pc = null; if (vs == null) { return; } foreach (VSProject p in vs.projects) { if (File.Exists(p.FileName) == false) { continue; } pc = p.LoadProjectToMemory(); p.Shuffle(pc); } MockProject(); }
public static void RemoveEnsureImportedTarget(MsBuildProject buildProject, string targetsPath) { var targetElement = buildProject.Xml.Targets.FirstOrDefault( target => string.Equals(target.Name, targetName, StringComparison.OrdinalIgnoreCase)); if (targetElement == null) { return; } string errorCondition = "!Exists('" + targetsPath + "')"; var taskElement = targetElement.Tasks.FirstOrDefault( task => string.Equals(task.Condition, errorCondition, StringComparison.OrdinalIgnoreCase)); if (taskElement == null) { return; } taskElement.Parent.RemoveChild(taskElement); if (targetElement.Tasks.Count == 0) { targetElement.Parent.RemoveChild(targetElement); } }
public void SetImportPath(string importPath, Project prj) { object service = null; IVsSolution solution = null; IVsHierarchy hierarchy = null; ProjectImportElement importProject; int?result = 0; service = GetServiceObject(prj.DTE, typeof(IVsSolution)); solution = (IVsSolution)service; result = solution?.GetProjectOfUniqueName(prj.UniqueName, out hierarchy); IVsProject project = (IVsProject)hierarchy; Microsoft.Build.Evaluation.Project msbuildProject = MSBuildProjectFromIVsProject(project); if (msbuildProject == null) { msbuildProject = ForceLoadMSBuildProjectFromIVsProject(project); } importProject = msbuildProject.Xml.AddImport(importPath); importProject.Label = "Shared"; msbuildProject.Save(); UnloadMSbuildProject(msbuildProject); }
/// <summary> /// Retrives the list of project guids from the project file. /// If you don't want your project to be flavorable, override /// to only return your project factory Guid: /// return this.GetType().GUID.ToString("B"); /// </summary> /// <param name="file">Project file to look into to find the Guid list</param> /// <returns>List of semi-colon separated GUIDs</returns> protected override string ProjectTypeGuids(string file) { // Load the project so we can extract the list of GUIDs this.buildProject = Utilities.ReinitializeMsBuildProject(this.buildEngine, file, this.buildProject); // Retrieve the list of GUIDs, if it is not specify, make it our GUID string guids = buildProject.GetPropertyValue(ProjectFileConstants.ProjectTypeGuids); if (String.IsNullOrEmpty(guids)) guids = this.GetType().GUID.ToString("B"); return guids; }
/// <summary> /// Rather than directly creating the project, ask VS to initate the process of /// creating an aggregated project in case we are flavored. We will be called /// on the IVsAggregatableProjectFactory to do the real project creation. /// </summary> /// <param name="fileName">Project file</param> /// <param name="location">Path of the project</param> /// <param name="name">Project Name</param> /// <param name="flags">Creation flags</param> /// <param name="projectGuid">Guid of the project</param> /// <param name="project">Project that end up being created by this method</param> /// <param name="canceled">Was the project creation canceled</param> protected override void CreateProject(string fileName, string location, string name, uint flags, ref Guid projectGuid, out IntPtr project, out int canceled) { project = IntPtr.Zero; canceled = 0; if ((flags & ((uint)__VSCREATEPROJFLAGS2.CPF_DEFERREDSAVE)) != 0) { throw new NotSupportedException(SR.GetString(SR.NoZeroImpactProjects)); } #if FX_ATLEAST_45 if ((flags & ((uint)__VSCREATEPROJFLAGS.CPF_OPENFILE)) != 0) { if (new ProjectInspector(fileName).IsPoisoned(Site)) { // error out int ehr = unchecked((int)0x80042003); // VS_E_INCOMPATIBLEPROJECT ErrorHandler.ThrowOnFailure(ehr); } } #endif // Get the list of GUIDs from the project/template string guidsList = this.ProjectTypeGuids(fileName); // Launch the aggregate creation process (we should be called back on our IVsAggregatableProjectFactoryCorrected implementation) IVsCreateAggregateProject aggregateProjectFactory = (IVsCreateAggregateProject)this.Site.GetService(typeof(SVsCreateAggregateProject)); int hr = aggregateProjectFactory.CreateAggregateProject(guidsList, fileName, location, name, flags, ref projectGuid, out project); if (hr == VSConstants.E_ABORT) canceled = 1; ErrorHandler.ThrowOnFailure(hr); this.buildProject = null; }
// This method is to restore the property value with old one when configuration goes wrong. // Unlike SetConfigurationProperty(), this method won't reevaluate the project prior to add the value, which may raise exceptions. private void RestoreConfigurationProperty(string propertyName, string propertyValue) { string condition = this.configCanonicalName.ToMSBuildCondition(); // Get properties for current configuration from project file and cache it MSBuildProject.SetGlobalProperty(this.project.BuildProject, ProjectFileConstants.Configuration, configCanonicalName.ConfigName); MSBuildProject.SetGlobalProperty(this.project.BuildProject, ProjectFileConstants.Platform, configCanonicalName.MSBuildPlatform); this.evaluatedProject = this.project.BuildProject; SetPropertyUnderConditionImpl(propertyName, propertyValue, condition); this.evaluatedProject = null; UpdateOutputGroup(); }
/// <summary> /// Loads each MSBuild project in this solution and looks for its project-to-project references so that /// we know what build order we should use when building the solution. /// </summary> private void ScanProjectDependencies(string childProjectToolsVersion, string fullSolutionConfigurationName) { // Don't bother with all this if the solution configuration doesn't even exist. if (fullSolutionConfigurationName == null) { return; } foreach (ProjectInSolution project in _solutionFile.ProjectsInOrder) { // We only need to scan .wdproj projects: Everything else is either MSBuildFormat or // something we don't know how to do anything with anyway if (project.ProjectType == SolutionProjectType.WebDeploymentProject) { // Skip the project if we don't have its configuration in this solution configuration if (!project.ProjectConfigurations.ContainsKey(fullSolutionConfigurationName)) { continue; } try { Project msbuildProject = new Project(project.AbsolutePath, _globalProperties, childProjectToolsVersion); // ProjectDependency items work exactly like ProjectReference items from the point of // view of determining that project B depends on project A. This item must cause // project A to be built prior to project B. // // This has the format // <ProjectDependency Include="DependentProjectRelativePath"> // <Project>{GUID}</Project> // </Project> IEnumerable<ProjectItem> references = msbuildProject.GetItems("ProjectDependency"); foreach (ProjectItem reference in references) { string referencedProjectGuid = reference.GetMetadataValue("Project"); AddDependencyByGuid(project, referencedProjectGuid); } // If this is a web deployment project, we have a reference specified as a property // "SourceWebProject" rather than as a ProjectReference item. This has the format // {GUID}|PATH_TO_CSPROJ // where // GUID is the project guid for the "source" project // PATH_TO_CSPROJ is the solution-relative path to the csproj file. // // NOTE: This is obsolete and is intended only for backward compatability with // Whidbey-generated web deployment projects. New projects should use the // ProjectDependency item above. string referencedWebProjectGuid = msbuildProject.GetPropertyValue("SourceWebProject"); if (!string.IsNullOrEmpty(referencedWebProjectGuid)) { // Grab the guid with its curly braces... referencedWebProjectGuid = referencedWebProjectGuid.Substring(0, 38); AddDependencyByGuid(project, referencedWebProjectGuid); } } catch (Exception e) { // We don't want any problems scanning the project file to result in aborting the build. if (ExceptionHandling.IsCriticalException(e)) { throw; } _loggingService.LogWarning ( _projectBuildEventContext, "SubCategoryForSolutionParsingErrors", new BuildEventFileInfo(project.RelativePath), "SolutionScanProjectDependenciesFailed", project.RelativePath, e.Message ); } } } }
private void EnsureCache() { // Get properties for current configuration from project file and cache it this.project.SetConfiguration(configCanonicalName); this.evaluatedProject = this.project.BuildProject; // REVIEW: The call below will set the Project configuration to the Solution configuration // for the purpose of evaluating properties - this is exactly what we don't want to do. // Can anyone think of a reason why we'd want to keep it? //project.SetCurrentConfiguration(); }
public virtual void SetConfigurationProperty(string propertyName, string propertyValue) { if (!this.project.QueryEditProjectFile(false)) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } string condition = this.configCanonicalName.ToMSBuildCondition(); SetPropertyUnderCondition(propertyName, propertyValue, condition); // property cache will need to be updated this.evaluatedProject = null; UpdateOutputGroup(); }
private static void SetMsBuildProjectProperty(MsBuildProject buildProject, string name, string value) { if (!value.Equals(buildProject.GetPropertyValue(name), StringComparison.OrdinalIgnoreCase)) { buildProject.SetProperty(name, value); } }
public void TestAddPropertyGroupForSolutionConfigurationBuildProjectInSolutionNotSet() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project('{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}') = 'ClassLibrary1', 'ClassLibrary1\ClassLibrary1.csproj', '{6185CC21-BE89-448A-B3C0-D1C27112E595}' EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Mixed Platforms = Debug|Mixed Platforms Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {6185CC21-BE89-448A-B3C0-D1C27112E595}.Debug|Mixed Platforms.ActiveCfg = CSConfig1|Any CPU EndGlobalSection EndGlobal "; SolutionFile solution = SolutionFile_Tests.ParseSolutionHelper(solutionFileContents); ProjectRootElement projectXml = ProjectRootElement.Create(); foreach (SolutionConfigurationInSolution solutionConfiguration in solution.SolutionConfigurations) { SolutionProjectGenerator.AddPropertyGroupForSolutionConfiguration(projectXml, solution, solutionConfiguration); } Project msbuildProject = new Project(projectXml); // Both projects configurations should be present for solution configuration "Debug|Mixed Platforms" msbuildProject.SetGlobalProperty("Configuration", "Debug"); msbuildProject.SetGlobalProperty("Platform", "Mixed Platforms"); msbuildProject.ReevaluateIfNecessary(); string solutionConfigurationContents = msbuildProject.GetPropertyValue("CurrentSolutionConfigurationContents"); Assert.IsTrue(solutionConfigurationContents.Contains(@"BuildProjectInSolution=""" + bool.FalseString + @"""")); }
private void AddNuGetTargets(MsBuildProject buildProject) { string targetsPath = Path.Combine(@"$(SolutionDir)", NuGetTargetsFile); NuGet.MSBuildProjectUtility.AddImportStatement(buildProject, targetsPath, ProjectImportLocation.Bottom); }
private void AddSolutionDirProperty(MsBuildProject buildProject) { const string solutiondir = "SolutionDir"; if (buildProject.Xml.Properties == null || buildProject.Xml.Properties.All(p => p.Name != solutiondir)) { string relativeSolutionPath = PathUtility.GetRelativePath( buildProject.FullPath, PathUtility.EnsureTrailingSlash(_solutionManager.SolutionDirectory)); relativeSolutionPath = PathUtility.EnsureTrailingSlash(relativeSolutionPath); var solutionDirProperty = buildProject.Xml.AddProperty(solutiondir, relativeSolutionPath); solutionDirProperty.Condition = String.Format( CultureInfo.InvariantCulture, @"$({0}) == '' Or $({0}) == '*Undefined*'", solutiondir); } }
private void EnablePackageRestore(Project project, MsBuildProject buildProject, bool saveProjectWhenDone) { AddSolutionDirProperty(buildProject); AddNuGetTargets(buildProject); SetMsBuildProjectProperty(buildProject, "RestorePackages", "true"); if (saveProjectWhenDone) { project.Save(); } }
/// <summary> /// Saves a .props file for the specified package, containing the paradox version (only Major.Minor) /// used to compile the package. /// </summary> /// <param name="package">The package.</param> public static void SaveProperties(Package package) { // Props file is in the same folder as the pdxpkg file, just with a ".props" extension. var packagePath = package.FullPath; var propsFilePath = UPath.Combine(packagePath.GetParent(), (UFile)(packagePath.GetFileName() + ".props")) ; var projectCollection = new Microsoft.Build.Evaluation.ProjectCollection(); var project = new Microsoft.Build.Evaluation.Project(projectCollection); var commonPropertyGroup = project.Xml.AddPropertyGroup(); var dependencies = package.FindDependencies(false, false, true); // Add Paradox version var pdxVersion = dependencies.FirstOrDefault(d => d.Meta.Name == "Paradox"); if (pdxVersion != null) { var versionText = pdxVersion.Meta.Version.Version.Major + "." + pdxVersion.Meta.Version.Version.Minor; commonPropertyGroup.AddProperty("SiliconStudioPackageParadoxVersion", versionText); } if (File.Exists(propsFilePath)) { File.Delete(propsFilePath); } project.Save(propsFilePath); }
public BasicTests() { this.nuproj = Assets.FromTemplate() .AssignNuProjDirectory() .ToProject(); }
private static void AddStepDefinitonToIntelliSenseProject(List<NodeFeature> features, string pathToFeatureFile, string pathToIntelliSenseProject) { foreach (var feature in features) { List<StepInstance> si = new List<StepInstance>(); var steps = new List<NodeStep>(); feature.Scenarios.ForEach(s => steps.AddRange(s.Steps)); var uniqueSteps = GeneratorHelper.FindUniqueSteps(new List<NodeStep>(), steps); foreach (var step in uniqueSteps) { StepDefinitionType type; StepDefinitionKeyword keyword; string stepNameWithoutType; if (step.Name.StartsWith("Given")) { type = StepDefinitionType.Given; keyword = StepDefinitionKeyword.Given; stepNameWithoutType = step.Name.Substring("Given".Length); } else if (step.Name.StartsWith("When")) { type = StepDefinitionType.When; keyword = StepDefinitionKeyword.When; stepNameWithoutType = step.Name.Substring("When".Length); } else { type = StepDefinitionType.Then; keyword = StepDefinitionKeyword.Then; stepNameWithoutType = step.Name.Substring("Then".Length); } string scenarioName = feature.Scenarios.First(scenario => scenario.Steps.Contains(step)).Name; si.Add(new StepInstance(type, keyword, stepNameWithoutType, stepNameWithoutType, new StepContext(feature.Name, scenarioName, new List<string>(), CultureInfo.CurrentCulture))); } var stepDefSkeleton = new StepDefinitionSkeletonProvider(new SpecFlowCSkeletonTemplateProvider(), new StepTextAnalyzer()); var template = stepDefSkeleton.GetBindingClassSkeleton(TechTalk.SpecFlow.ProgrammingLanguage.CSharp, si.ToArray(), "CppUnitTest", feature.Name, StepDefinitionSkeletonStyle.MethodNamePascalCase, CultureInfo.CurrentCulture); string basePathToFeatures = Path.GetDirectoryName(pathToFeatureFile); string basePathToIntelliSenseProject = Path.GetDirectoryName(pathToIntelliSenseProject); _csProj = _csProj ?? GetUnloadedProject(pathToIntelliSenseProject); var stepDefinitionDirPathInProj = string.Format("Steps\\{0}\\", PROJECT_NAME); var stepDefinitionDirPath = string.Format("{0}\\{1}", basePathToIntelliSenseProject, stepDefinitionDirPathInProj); var filePathInProjFile = string.Format("{0}{1}_step.cs", stepDefinitionDirPathInProj, feature.Name); var filePath = string.Format("{0}{1}_step.cs", stepDefinitionDirPath, feature.Name); if (!_csProj.GetItems("Compile").Any(item => item.UnevaluatedInclude == filePathInProjFile)) { Console.WriteLine(string.Format("Generating Step Definition file for IntelliSense support: {0}", filePathInProjFile)); Directory.CreateDirectory(stepDefinitionDirPath); File.WriteAllText(filePath, template); _csProj.AddItem("Compile", filePathInProjFile); _isDirtyCsProj = true; } } }
private static Microsoft.Build.Evaluation.Project GetUnloadedProject(string projectPath) { var project = new Microsoft.Build.Evaluation.Project(projectPath); project.ProjectCollection.UnloadAllProjects(); return project; }