private void EnsureGroupsCreated()
{
if (_autoPackageVersions == null)
{
_autoPackageVersions = _document.AddPropertyGroup();
_autoPackageVersions.Label = AutoPackageVersionsLabel;
}
if (_pinnedPackageVersions == null)
{
_pinnedPackageVersions = _document.AddPropertyGroup();
_pinnedPackageVersions.Label = PinnedPackageVersionsLabel;
}
}
private void GenerateAndAddLegacyConfigurationPropertyGroup()
{
ProjectPropertyGroupElement group = Xml.AddPropertyGroup();
group.AddProperty("ProjectGuidString", Guid.NewGuid().ToString("B").ToUpper());
group.AddProperty("ProjectTypeGuids", VsProjectTypeGuids.LegacyProjectGuid);
}
public override void Process(
string sourcePath,
ProjectRootElement project,
Dictionary <string, ProjectPropertyGroupElement> groups
)
{
ProjectPropertyGroupElement globals;
if (!groups.TryGetValue("Globals", out globals))
{
globals = project.AddPropertyGroup();
}
AddOrSetProperty(globals, "StartupFile", "manage.py");
AddOrSetProperty(globals, "ProjectTypeGuids", "{5F0BE9CA-D677-4A4D-8806-6076C0FAAD37};{349c5851-65df-11da-9384-00065b846f21};{888888a0-9f3d-457c-b088-3a5042f75d52}");
AddOrSetProperty(globals, "LaunchProvider", "Django launcher");
AddOrSetProperty(globals, "WebBrowserUrl", "http://localhost");
var settingsFilePath = PathUtils.FindFile(sourcePath, "settings.py", depthLimit: 1);
if (File.Exists(settingsFilePath))
{
var packageName = PathUtils.GetLastDirectoryName(settingsFilePath);
AddOrSetProperty(globals, "DjangoSettingsModule", "{0}.settings".FormatInvariant(packageName));
}
project.AddImport(@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.Django.targets");
GenericWebProjectCustomization.AddWebProjectExtensions(project);
}
public void MigratingScriptsWithMultipleCommandsCreatesExecTaskForEach(string scriptName)
{
var scriptMigrationRule = new MigrateScriptsRule();
ProjectRootElement mockProj = ProjectRootElement.Create();
ProjectPropertyGroupElement commonPropertyGroup = mockProj.AddPropertyGroup();
var commands = new[] { "fakecommand1", "fakecommand2", "mockcommand3" };
var commandsInTask = commands.ToDictionary(c => c, c => false);
var target = scriptMigrationRule.MigrateScriptSet(
mockProj,
commonPropertyGroup,
commands,
scriptName,
IsMultiTFM);
foreach (var task in target.Tasks)
{
var taskCommand = task.GetParameter("Command");
var originalCommandCandidates = commands.Where(c => taskCommand.Contains(c));
originalCommandCandidates.Count().Should().Be(1);
var command = originalCommandCandidates.First();
commandsInTask[command]
.Should().Be(false, "Expected to find each element from commands Array once");
commandsInTask[command] = true;
}
commandsInTask.All(commandInTask => commandInTask.Value)
.Should()
.BeTrue("Expected each element from commands array to be found in a task");
}
public void Migrated_ScriptSet_has_two_MigratedScriptExtensionProperties_for_each_script(string scriptName)
{
var scriptMigrationRule = new MigrateScriptsRule();
ProjectRootElement mockProj = ProjectRootElement.Create();
var commands = new string[] { "compile:FullTargetFramework", "compile:Configuration" };
var propertyGroup = mockProj.AddPropertyGroup();
var target = scriptMigrationRule.MigrateScriptSet(mockProj, propertyGroup, commands,
scriptName);
Console.WriteLine(string.Join(";", propertyGroup.Properties.Select(n => n.Name)));
propertyGroup.Properties.Count().Should().Be(commands.Length * 2);
var count = 0;
foreach (var command in commands)
{
count += 1;
var scriptExtensionProperties =
propertyGroup.Properties.Where(p => p.Name.Contains($"MigratedScriptExtension_{scriptName}_{count}")).ToArray();
scriptExtensionProperties.All(p => p.Value == ".sh" || p.Value == ".cmd").Should().BeTrue();
scriptExtensionProperties.Count().Should().Be(2);
}
}
private void AssertInputs(string ruleSetPath, IList <string> expectedInputs)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, "project.proj"));
if (ruleSetPath != null)
{
ProjectPropertyGroupElement propertyGroup = projectRootElement.AddPropertyGroup();
projectRootElement.AddProperty(CodeAnalysisRuleSetPredictor.CodeAnalysisRuleSetPropertyName, ruleSetPath);
}
var projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = expectedInputs?
.Select(input => new PredictedItem(input, nameof(CodeAnalysisRuleSetPredictor)))
.ToArray();
_predictor
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles,
null,
null,
null);
}
public void MigratedScriptSetHasExecAndReplacesVariables(string scriptName)
{
var scriptMigrationRule = new MigrateScriptsRule();
ProjectRootElement mockProj = ProjectRootElement.Create();
ProjectPropertyGroupElement commonPropertyGroup = mockProj.AddPropertyGroup();
var commands = new[] { "%compile:FullTargetFramework%", "%compile:Configuration%" };
var target = scriptMigrationRule.MigrateScriptSet(
mockProj,
commonPropertyGroup,
commands,
scriptName,
IsMultiTFM);
target.Tasks.Count().Should().Be(commands.Length);
foreach (var task in target.Tasks)
{
var taskCommand = task.GetParameter("Command");
var commandIndex = Array.IndexOf(commands, taskCommand);
commandIndex.Should().Be(
-1,
"Expected command array elements to be replaced by appropriate msbuild properties");
}
}
private ProjectRootElement CreateProject()
{
Microsoft.Build.Evaluation.Project project = null;
try
{
project = Microsoft.Expression.Project.Build.BuildManager.GetProject(DocumentReference.Create(this.originalProjectFilePath));
}
catch (ArgumentException argumentException)
{
}
ProjectRootElement projectRootElement = ProjectRootElement.Create();
projectRootElement.ToolsVersion = "4.0";
this.AddBuildProperties(projectRootElement, project);
projectRootElement.AddItemGroup();
projectRootElement.AddPropertyGroup();
projectRootElement.AddProperty("IntermediateOutputPath", Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath));
this.AddAssemblyReferences(projectRootElement, project);
this.AddImports(projectRootElement, project);
if (!this.IsSilverlightApplication(project))
{
this.AddWpfImports(projectRootElement);
}
projectRootElement.AddItem("Page", this.xamlPath);
string str = Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath), "MarkupCompileAssembly.proj");
projectRootElement.Save(str);
return(projectRootElement);
}
private static ProjectInstance CreateTestProjectInstance(string fileName, bool hasProjectReferences = true, bool isEnabled = true)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create($@"ServiceFabricApp\{fileName}");
// These are generally set in Microsoft.VisualStudio.Azure.Fabric.Application.targets
ProjectPropertyGroupElement propertyGroup = projectRootElement.AddPropertyGroup();
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.ApplicationPackageRootFolderPropertyName, "ApplicationPackageRoot");
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.ServicePackageRootFolderPropertyName, "PackageRoot");
if (isEnabled)
{
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.UpdateServiceFabricApplicationManifestEnabledPropertyName, "true");
}
if (hasProjectReferences)
{
ProjectItemGroupElement itemGroup = projectRootElement.AddItemGroup();
itemGroup.AddItem(ServiceFabricServiceManifestPredictor.ProjectReferenceItemName, @"..\Service1\Service1.csproj");
itemGroup.AddItem(ServiceFabricServiceManifestPredictor.ProjectReferenceItemName, @"..\Service2\Service2.csproj");
}
// Extra service manifests, and some extraneous files too
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent"); // Not in a subdir, should not get picked up
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\extraneous.txt", "SomeContent");
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot\Foo");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Foo\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Foo\extraneous.txt", "SomeContent");
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot\Bar");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Bar\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Bar\extraneous.txt", "SomeContent");
return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement));
}
static ProjectPropertyGroupElement CreatePropertyGroupChoice(ProjectRootElement root,
string condition,
bool unsafeMode, string outputPath, bool optimize,
bool debugSymbol, string debugType, string constants
)
{
ProjectPropertyGroupElement group = root.AddPropertyGroup();
group.Condition = condition;
if (unsafeMode)
{
group.AddProperty("AllowUnsafeBlocks", "true");
}
group.AddProperty("ErrorReport", "prompt");
group.AddProperty("WarningLevel", "4");
group.AddProperty("OutputPath", outputPath); //,eg @"bin\Debug\"
group.AddProperty("Optimize", optimize ? "true" : "false");
group.AddProperty("DebugType", debugType);
if (debugSymbol)
{
group.AddProperty("DebugSymbols", "true");
}
group.AddProperty("DefineConstants", constants); //eg DEBUG; TRACE
return(group);
}
/// <summary>
/// copy properties from g into a new property group for newConfiguration and newPlatform
/// </summary>
void CopyProperties(ProjectRootElement project, ProjectPropertyGroupElement g, ConfigurationAndPlatform newConfig)
{
ProjectPropertyGroupElement ng = project.AddPropertyGroup();
ng.Condition = newConfig.ToCondition();
foreach (var p in g.Properties)
{
ng.AddProperty(p.Name, p.Value).Condition = p.Condition;
}
}
public void Migrating_post_scripts_populates_AfterTargets_with_appropriate_target(string scriptName, string targetName)
{
var scriptMigrationRule = new MigrateScriptsRule();
ProjectRootElement mockProj = ProjectRootElement.Create();
var commands = new[] { "fakecommand" };
var target = scriptMigrationRule.MigrateScriptSet(mockProj, mockProj.AddPropertyGroup(), commands, scriptName);
target.AfterTargets.Should().Be(targetName);
}
private static void InitializeCPSClassLibraryConfigurationProperties(
ProjectRootElement root, string assemblyName, string rootNamespace, string outputType, string targetFramework)
{
ProjectPropertyGroupElement group = root.AddPropertyGroup();
group.Label = "Configuration";
group.AddProperty("AssemblyName", assemblyName);
group.AddProperty("RootNamespace", rootNamespace);
group.AddProperty("OutputType", outputType);
group.AddProperty("TargetFramework", targetFramework);
}
public void Migrating_scripts_creates_target_with_IsCrossTargettingBuild_not_equal_true_Condition()
{
var scriptMigrationRule = new MigrateScriptsRule();
ProjectRootElement mockProj = ProjectRootElement.Create();
var commands = new[] { "compile:FullTargetFramework", "compile:Configuration" };
var target = scriptMigrationRule.MigrateScriptSet(mockProj, mockProj.AddPropertyGroup(), commands, "prepublish");
target.Condition.Should().Be(" '$(IsCrossTargetingBuild)' != 'true' ");
}
protected override void UpgradeProject(ref ProjectRootElement projectXml, ref ProjectRootElement userProjectXml, Action <__VSUL_ERRORLEVEL, string> log)
{
var envVarsProp = projectXml.Properties.FirstOrDefault(p => p.Name == NodejsConstants.EnvironmentVariables);
if (envVarsProp != null)
{
var globals = projectXml.PropertyGroups.FirstOrDefault() ?? projectXml.AddPropertyGroup();
AddOrSetProperty(globals, NodejsConstants.Environment, envVarsProp.Value.Replace(";", "\r\n"));
envVarsProp.Parent.RemoveChild(envVarsProp);
log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, SR.GetString(SR.UpgradedEnvironmentVariables));
}
}
public void Migrating_scripts_throws_on_invalid_ScriptSet()
{
var scriptMigrationRule = new MigrateScriptsRule();
ProjectRootElement mockProj = ProjectRootElement.Create();
var commands = new string[] { "fakecommand" };
Action action = () => scriptMigrationRule.MigrateScriptSet(mockProj, mockProj.AddPropertyGroup(), commands, "invalidScriptSet");
action.ShouldThrow <MigrationException>()
.WithMessage("MIGRATE1019::Unsupported Script Event Hook: invalidScriptSet is an unsupported script event hook for project migration");
}
public void Generate(string outputPath, string propertyVersionNamePrefix, string propertyPathNamePrefix, PackageRestoreData restoreData)
{
// Delete an existing file in case there are no properties generated and we don't end up saving the file
//
if (File.Exists(outputPath))
{
Retry(() => File.Delete(outputPath), TimeSpan.FromMilliseconds(500));
}
ProjectRootElement project = ProjectRootElement.Create();
ProjectPropertyGroupElement propertyGroup = project.AddPropertyGroup();
propertyGroup.SetProperty("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)");
ProjectItemGroupElement itemGroup = project.AddItemGroup();
bool anyPropertiesCreated = false;
foreach (string packageConfigPath in _packageConfigPaths)
{
_logger.LogMessage(MessageImportance.Low, $"Parsing '{packageConfigPath}'");
IEnumerable <PackageIdentityWithPath> parsedPackages = null;
INuGetPackageConfigParser configParser = null;
// A bug in nuget sometimes causes "NuGet.Configuration.NuGetConfigurationException: Unexpected failure reading NuGet.Config." when multiple instances are running in parrallel such as in the quickbuild scenario.
Retry(() => configParser = _configParsersLazy.Value.FirstOrDefault(i => i.TryGetPackages(packageConfigPath, restoreData, out parsedPackages)), TimeSpan.FromMilliseconds(1000));
if (configParser != null && parsedPackages != null)
{
anyPropertiesCreated = true;
foreach (PackageIdentityWithPath packageInfo in parsedPackages)
{
propertyGroup.SetProperty($"{propertyPathNamePrefix}{packageInfo.Id.Replace(".", "_")}", $"{packageInfo.FullPath}");
propertyGroup.SetProperty($"{propertyVersionNamePrefix}{packageInfo.Id.Replace(".", "_")}", $"{packageInfo.Version.ToString()}");
// Consider adding item metadata of packageid and version for ease of consumption of this property.
itemGroup.AddItem("CBTNuGetPackageDir", packageInfo.FullPath);
}
}
}
// Don't save the file if no properties were created. In Visual Studio design time builds, this can be called multiple times until there are finally
// properties that can be created. If we generate an empty file, it won't get regenerated once there are properties to create.
//
if (anyPropertiesCreated)
{
Retry(() => project.Save(outputPath), TimeSpan.FromMilliseconds(500));
}
}
public void WriteDirectoryBuildProps(ISolutionOptions options)
{
string strongNameKeyDirectory = Path.Combine(options.RepositoryDirectory, "build\\strong name keys\\");
string strongNameKeyFile = Path.Combine(strongNameKeyDirectory, $"{options.SolutionName}SharedKey.snk");
Directory.CreateDirectory(strongNameKeyDirectory);
ProjectRootElement root = ProjectRootElement.Create(NewProjectFileOptions.None);
ProjectPropertyGroupElement p0 = root.AddPropertyGroup();
p0.AddProperty("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)");
ProjectPropertyGroupElement p1 = root.AddPropertyGroup();
p1.AddDefaultProperty("DisableStandardFrameworkResolution", "false");
p1.AddDefaultProperty("AppendTargetFrameworkToOutputDirectory", "false");
ProjectPropertyGroupElement p3 = root.AddPropertyGroup();
p3.AddProperty("SolutionDir", "$(MSBuildThisFileDirectory)");
p3.AddProperty("RepositoryDirectory", "$([System.IO.Path]::GetFullPath('$(SolutionDir)..\\'))");
p3.AddDefaultProperty("OutputPath", @"$([System.IO.Path]::GetFullPath('$(RepositoryDirectory)bin\$(Configuration)\$(MSBuildProjectName)\'))");
p3.AddDefaultProperty("IntermediateOutputPath", @"$([System.IO.Path]::GetFullPath('$(RepositoryDirectory)bin\obj\$(MSBuildProjectName)\$(Configuration)\'))");
StrongNameKeyInfo snk = StrongNameKeyManager.GenerateStrongNameKeyInfo();
ProjectPropertyGroupElement signingProperties = root.AddPropertyGroup();
signingProperties.AddDefaultProperty("SignAssembly", "true");
signingProperties.AddDefaultProperty("AssemblyOriginatorKeyFile", "$(RepositoryDirectory)build\\strong name keys\\$(SolutionName)SharedKey.snk");
signingProperties.AddDefaultProperty("PublicKey", snk.PublicKey);
signingProperties.AddDefaultProperty("PublicKeyToken", snk.PublicKeyToken);
File.WriteAllBytes(strongNameKeyFile, snk.RawBytes);
root.Save(options.DirectoryBuildPropsPath);
}
private static void InitializeLegacyVSIXConfigurationProperties(
ProjectRootElement root, string assemblyName, string rootNamespace, string outputType, string targetFramework, string projectGuid)
{
ProjectPropertyGroupElement group = root.AddPropertyGroup();
group.Label = "Configuration";
group.AddProperty("ProjectGuid", projectGuid);
group.AddProperty("ProjectTypeGuids", VsProjectTypeGuids.ExtensibilityFlavorProjectGuid);
group.AddProperty("AssemblyName", assemblyName);
group.AddProperty("RootNamespace", rootNamespace);
group.AddProperty("OutputType", outputType);
group.AddProperty("TargetFrameworkVersion", targetFramework);
}
private static void ProcessImportsFrom21b(ProjectRootElement projectXml, Action <__VSUL_ERRORLEVEL, string> log)
{
var bottleImports = projectXml.Imports.Where(p => p.Project.Equals(Ptvs21BetaBottleTargets, StringComparison.OrdinalIgnoreCase)).ToList();
var flaskImports = projectXml.Imports.Where(p => p.Project.Equals(Ptvs21BetaFlaskTargets, StringComparison.OrdinalIgnoreCase)).ToList();
foreach (var import in bottleImports.Concat(flaskImports))
{
import.Project = WebTargets;
}
if (bottleImports.Any())
{
var globals = projectXml.PropertyGroups.FirstOrDefault() ?? projectXml.AddPropertyGroup();
AddOrSetProperty(globals, "PythonDebugWebServerCommandArguments", "--debug $(CommandLineArguments)");
AddOrSetProperty(globals, "PythonWsgiHandler", "{StartupModule}.wsgi_app()");
log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, Strings.UpgradedBottleImports);
}
if (flaskImports.Any())
{
var globals = projectXml.PropertyGroups.FirstOrDefault() ?? projectXml.AddPropertyGroup();
AddOrSetProperty(globals, "PythonWsgiHandler", "{StartupModule}.wsgi_app");
log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, Strings.UpgradedFlaskImports);
}
var commonPropsImports = projectXml.Imports.Where(p => p.Project.Equals(CommonProps, StringComparison.OrdinalIgnoreCase)).ToList();
foreach (var p in commonPropsImports)
{
projectXml.RemoveChild(p);
log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, Strings.UpgradedRemoveCommonProps);
}
if (projectXml.Imports.Count == 1 && projectXml.Imports.First().Project.Equals(CommonTargets, StringComparison.OrdinalIgnoreCase))
{
projectXml.RemoveChild(projectXml.Imports.First());
projectXml.AddImport(PtvsTargets);
log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, Strings.UpgradedRemoveCommonTargets);
}
}
public void SetCondition()
{
ProjectRootElement project = ProjectRootElement.Create();
project.AddPropertyGroup();
Helpers.ClearDirtyFlag(project);
ProjectPropertyGroupElement propertyGroup = Helpers.GetFirst(project.PropertyGroups);
propertyGroup.Condition = "c";
Assert.Equal("c", propertyGroup.Condition);
Assert.Equal(true, project.HasUnsavedChanges);
}
public override void Run()
{
Log.LogMessage("Generating module build package imports");
ProjectRootElement propsProject = ProjectRootElement.Create(PropsFile);
ProjectRootElement targetsProject = ProjectRootElement.Create(TargetsFile);
ProjectPropertyGroupElement propertyGroup = propsProject.AddPropertyGroup();
foreach (BuildPackageInfo buildPackageInfo in ModulePaths.Select(BuildPackageInfo.FromModulePath).Where(i => i != null))
{
if (buildPackageInfo.PropsPath == null && buildPackageInfo.TargetsPath == null)
{
Log.LogMessage(MessageImportance.Low, $" Skipping '{buildPackageInfo.Id}' because it is not a standard NuGet build package.");
continue;
}
// If this is a cbt module do not auto import props or targets.
if (File.Exists(Path.Combine(Path.GetDirectoryName(buildPackageInfo.PropsPath ?? buildPackageInfo.TargetsPath), "module.config")))
{
Log.LogMessage(MessageImportance.Low, $" Skipping '{buildPackageInfo.Id}' because it is a CBT Module.");
continue;
}
ProjectPropertyElement enableProperty = propertyGroup.AddProperty(buildPackageInfo.EnablePropertyName, "false");
enableProperty.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == '' ";
ProjectPropertyElement runProperty = propertyGroup.AddProperty(buildPackageInfo.RunPropertyName, "true");
runProperty.Condition = $" '$({buildPackageInfo.RunPropertyName})' == '' ";
if (File.Exists(buildPackageInfo.PropsPath))
{
ProjectImportElement import = propsProject.AddImport(buildPackageInfo.PropsPath);
import.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == 'true' And '$({buildPackageInfo.RunPropertyName})' == 'true' ";
}
if (File.Exists(buildPackageInfo.TargetsPath))
{
ProjectImportElement import = targetsProject.AddImport(buildPackageInfo.TargetsPath);
import.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == 'true' And '$({buildPackageInfo.RunPropertyName})' == 'true' ";
}
Log.LogMessage($" Generated imports for '{buildPackageInfo.Id}'.");
}
propsProject.Save();
targetsProject.Save();
}
public override void Process(
ProjectRootElement project,
Dictionary <string, ProjectPropertyGroupElement> groups
)
{
ProjectPropertyGroupElement globals;
if (!groups.TryGetValue("Globals", out globals))
{
globals = project.AddPropertyGroup();
}
AddOrSetProperty(globals, "ProjectTypeGuids", "{c85cbf2e-4147-4e9d-87e0-9a2fbf407f6e};{888888A0-9F3D-457C-B088-3A5042F75D52}");
}
private bool AddBuildProperties(ProjectRootElement inMemoryProject, Microsoft.Build.Evaluation.Project originalProject)
{
foreach (ProjectPropertyGroupElement propertyGroup in originalProject.Xml.PropertyGroups)
{
ProjectPropertyGroupElement condition = inMemoryProject.AddPropertyGroup();
condition.Condition = propertyGroup.Condition;
foreach (ProjectPropertyElement property in propertyGroup.Properties)
{
ProjectPropertyElement projectPropertyElement = condition.AddProperty(property.Name, property.Value);
projectPropertyElement.Condition = property.Condition;
}
}
return(true);
}
public override void Process(
ProjectRootElement project,
Dictionary <string, ProjectPropertyGroupElement> groups
)
{
ProjectPropertyGroupElement globals;
if (!groups.TryGetValue("Globals", out globals))
{
globals = project.AddPropertyGroup();
}
AddOrSetProperty(globals, "ProjectTypeGuids", "{2b557614-1a2b-4903-b9df-ed20d7b63f3a};{888888A0-9F3D-457C-B088-3A5042F75D52}");
}
private void AddTargetFrameworkProperty()
{
var propGroup = _projectRootElement.PropertyGroups.FirstOrDefault(pg => pg.Condition == "");
if (propGroup == null)
{
propGroup = _projectRootElement.AddPropertyGroup();
}
var targetFrameworkElement = _projectRootElement.CreatePropertyElement("TargetFramework");
targetFrameworkElement.Value = _sdkBaselineProject.Project.FirstConfiguredProject.GetProperty("TargetFramework").EvaluatedValue;
propGroup.PrependChild(targetFrameworkElement);
}
public void SetLabel()
{
ProjectRootElement project = ProjectRootElement.Create();
project.AddPropertyGroup();
Helpers.ClearDirtyFlag(project);
ProjectPropertyGroupElement propertyGroup = Helpers.GetFirst(project.PropertyGroups);
propertyGroup.Label = "c";
Assert.Equal("c", propertyGroup.Label);
Assert.True(project.HasUnsavedChanges);
}
public RepositoryProject(string repositoryRoot)
{
_doc = ProjectRootElement.Create(NewProjectFileOptions.None);
var import = _doc.CreateImportElement(@"$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props");
var propGroup = _doc.AddPropertyGroup();
if (repositoryRoot[repositoryRoot.Length - 1] != '\\')
{
repositoryRoot += '\\';
}
propGroup.AddProperty("RepositoryRoot", repositoryRoot);
_doc.AddItemGroup();
_doc.PrependChild(import);
_doc.AddImport(@"$(MSBuildToolsPath)\Microsoft.Common.targets");
}
internal void CreatePropsFile(IDictionary <string, string> propertyPairs, string propsFile)
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectPropertyGroupElement propertyGroup = project.AddPropertyGroup();
propertyGroup.SetProperty("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)");
foreach (var kvp in propertyPairs)
{
propertyGroup.SetProperty(kvp.Key, kvp.Value);
}
project.Save(propsFile);
}
private static void AddProperties(string projectName, ProjectRootElement root)
{
ProjectPropertyGroupElement group = root.AddPropertyGroup();
group.AddProperty("Configuration", "Debug");
group.AddProperty("Platform", "AnyCPU");
group.AddProperty("ProjectGuid", Guid.NewGuid().ToString());
group.AddProperty("OutputType", "Library");
group.AddProperty("AppDesignerFolder", "Properties");
group.AddProperty("RootNamespace", projectName);
group.AddProperty("AssemblyName", projectName);
group.AddProperty("TargetFrameworkVersion", "4.5.2");
ProjectPropertyGroupElement conditionedGroup = root.AddPropertyGroup();
conditionedGroup.AddProperty("DebugSymbols", "true");
conditionedGroup.AddProperty("DebugType", "full");
conditionedGroup.AddProperty("Optimize", "false");
conditionedGroup.AddProperty("OutputPath", "bin\\Debug\\");
conditionedGroup.AddProperty("DefineConstants", "DEBUG;TRACE");
conditionedGroup.AddProperty("ErrorReport", "prompt");
conditionedGroup.AddProperty("WarningLevel", "4");
conditionedGroup.Condition = " '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ";
}
