public static void AddTargetsFileToOldProjects(VCProject vcProject)
{
string projectFilePath = vcProject.ProjectFile;
ProjectRootElement projectRootElement = ProjectRootElement.Open(projectFilePath);
ICollection <ProjectImportElement> imports = projectRootElement.Imports;
ProjectPropertyGroupElement userMacrosPropertyGroup = projectRootElement.PropertyGroups.Where(g => g.Label.Equals("UserMacros")).FirstOrDefault();
ProjectImportElement userFileImport = imports.Where(i => i.Project.Equals("$(VCTargetsPath)\\Microsoft.Cpp.targets")).FirstOrDefault();
if (userMacrosPropertyGroup != null && !userMacrosPropertyGroup.NextSibling.Equals(userFileImport))
{
projectRootElement.RemoveChild(userFileImport);
projectRootElement.InsertAfterChild(userFileImport, userMacrosPropertyGroup);
//delete all occurences of PLCnCLIIncludes and PLCnCLIMacros -> saved in .users file now
IEnumerable <ProjectPropertyElement> elementsToDelete = projectRootElement.PropertyGroups
.Where(g => g.Label.Equals("Configuration"))
.SelectMany(g => g.Properties
.Where(p => p.Name.Equals("PLCnCLIMacros") || p.Name.Equals("PLCnCLIIncludes")));
elementsToDelete.ToList().ForEach(e => e.Parent.RemoveChild(e));
MessageBox.Show("The project file needs to be updated outside of the environment. Please choose 'Reload all...' in the next dialog.",
"Project update needed", MessageBoxButton.OK, MessageBoxImage.Exclamation);
projectRootElement.Save();
}
}
public static void AddImportStatement(this MsBuildProject buildProject, string targetsPath, ProjectImportLocation location)
{
// adds an <Import> element to this project file if it doesn't already exist.
if (buildProject.Xml.Imports == null ||
buildProject.Xml.Imports.All(import => !targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase)))
{
ProjectImportElement pie = buildProject.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);
buildProject.Xml.InsertBeforeChild(pie, buildProject.Xml.FirstChild);
}
else
{
// the import might get added into an ImportGroup. In this case,
// we remove it from the ImportGroup and add it at the end of the
// project.
if (pie.Parent.GetType() == typeof(ProjectImportGroupElement))
{
pie.Parent.RemoveChild(pie);
buildProject.Xml.AppendChild(pie);
}
}
NuGet.MSBuildProjectUtility.AddEnsureImportedTarget(buildProject, targetsPath);
buildProject.ReevaluateIfNecessary();
}
}
static ProjectImportElement AddImportAtTop(ProjectRootElement projectRoot, string importedProjectFile)
{
ProjectImportElement import = projectRoot.CreateImportElement(importedProjectFile);
projectRoot.InsertBeforeChild(import, projectRoot.FirstChild);
return(import);
}
IEnumerable <ProjectElement> Import(ProjectImportElement import)
{
string dir = ProjectCollection.GetEvaluationTimeThisFileDirectory(() => FullPath);
// FIXME: use appropriate logger (but cannot be instantiated here...?)
string path = ProjectCollection.FindFileInSeveralExtensionsPath(ref extensions_path_override, ExpandString, import.Project, TextWriter.Null.WriteLine);
path = Path.IsPathRooted(path) ? path : dir != null?Path.Combine(dir, path) : Path.GetFullPath(path);
if (ProjectCollection.OngoingImports.Contains(path))
{
switch (load_settings)
{
case ProjectLoadSettings.RejectCircularImports:
throw new InvalidProjectFileException(import.Location, null, string.Format("Circular imports was detected: {0} (resolved as \"{1}\") is already on \"importing\" stack", import.Project, path));
}
return(new ProjectElement [0]); // do not import circular references
}
ProjectCollection.OngoingImports.Push(path);
try {
using (var reader = XmlReader.Create(path)) {
var root = ProjectRootElement.Create(reader, ProjectCollection);
raw_imports.Add(new ResolvedImport(import, root, true));
return(this.EvaluatePropertiesAndImportsAndChooses(root.Children).ToArray());
}
} finally {
ProjectCollection.OngoingImports.Pop();
}
}
IEnumerable <ProjectElement> Import(ProjectImportElement import)
{
string dir = ProjectCollection.GetEvaluationTimeThisFileDirectory(() => FullPath);
string path = WindowsCompatibilityExtensions.FindMatchingPath(ExpandString(import.Project));
path = Path.IsPathRooted(path) ? path : dir != null?Path.Combine(dir, path) : Path.GetFullPath(path);
if (ProjectCollection.OngoingImports.Contains(path))
{
switch (load_settings)
{
case ProjectLoadSettings.RejectCircularImports:
throw new InvalidProjectFileException(import.Location, null, string.Format("Circular imports was detected: {0} (resolved as \"{1}\") is already on \"importing\" stack", import.Project, path));
}
return(new ProjectElement [0]); // do not import circular references
}
ProjectCollection.OngoingImports.Push(path);
try {
using (var reader = XmlReader.Create(path)) {
var root = ProjectRootElement.Create(reader, ProjectCollection);
raw_imports.Add(new ResolvedImport(import, root, true));
return(this.EvaluatePropertiesAndImports(root.Children).ToArray());
}
} finally {
ProjectCollection.OngoingImports.Pop();
}
}
protected ImportElement GetImportElement(ProjectImportElement element)
{
return((element == null) ? default : new ImportElement(element)
{
parentProject = this
});
}
public void SdkReferenceIsCorrect_CreatedFromOnDiskProject_SdkAttributeSet()
{
using (TestEnvironment testEnvironment = TestEnvironment.Create())
{
TransientTestFile projectFile = testEnvironment.CreateFile(
"test.proj",
@"
<Project>
<Import Project=""Sdk.props"" Sdk=""My.Sdk"" />
</Project>");
ProjectRootElement rootElement = ProjectRootElement.Open(projectFile.Path);
ProjectImportElement importElement = rootElement.Imports.First();
importElement.SdkReference.Name.ShouldBe("My.Sdk");
importElement.SdkReference.Version.ShouldBeNull();
importElement.SdkReference.MinimumVersion.ShouldBeNull();
SetPropertyAndExpectProjectXmlChangedEventToNotFire(rootElement, () => importElement.Sdk = "My.Sdk");
SetPropertyAndExpectProjectXmlChangedEventToFire(rootElement, () => importElement.Version = "1.2.0", "Set Import Version 1.2.0");
SetPropertyAndExpectProjectXmlChangedEventToNotFire(rootElement, () => importElement.Version = "1.2.0");
importElement.SdkReference.Name.ShouldBe("My.Sdk");
importElement.SdkReference.Version.ShouldBe("1.2.0");
importElement.SdkReference.MinimumVersion.ShouldBeNull();
SetPropertyAndExpectProjectXmlChangedEventToFire(rootElement, () => importElement.MinimumVersion = "1.0.0", "Set Import Minimum Version 1.0.0");
SetPropertyAndExpectProjectXmlChangedEventToNotFire(rootElement, () => importElement.MinimumVersion = "1.0.0");
importElement.SdkReference.Name.ShouldBe("My.Sdk");
importElement.SdkReference.Version.ShouldBe("1.2.0");
importElement.SdkReference.MinimumVersion.ShouldBe("1.0.0");
}
}
private static void AddImports(ProjectRootElement root)
{
root.AddImport("$(MSBuildToolsPath)\\Microsoft.CSharp.targets");
ProjectImportElement import = root.AddImport("$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props");
import.Condition = "Exists('$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props')";
}
public void SettingConditionDirties()
{
string file = null;
try
{
file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
ProjectRootElement importProject = ProjectRootElement.Create();
importProject.AddProperty("p", "v1");
importProject.Save(file);
string content = String.Format
(
@"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' >
<Import Project='{0}'/>
</Project>",
file
);
Project project = new Project(XmlReader.Create(new StringReader(content)));
ProjectImportElement import = Helpers.GetFirst(project.Xml.Imports);
import.Condition = "false";
Assert.Equal("v1", project.GetPropertyValue("p"));
project.ReevaluateIfNecessary();
Assert.Equal(String.Empty, project.GetPropertyValue("p"));
}
finally
{
File.Delete(file);
}
}
IEnumerable <ProjectElement> Import(ProjectImportElement import)
{
string dir = projects.GetEvaluationTimeThisFileDirectory(() => FullPath);
string path = WindowsCompatibilityExtensions.NormalizeFilePath(ExpandString(import.Project));
path = Path.IsPathRooted(path) ? path : dir != null?Path.Combine(dir, path) : Path.GetFullPath(path);
if (projects.OngoingImports.Contains(path))
{
throw new InvalidProjectFileException(import.Location, null, string.Format("Circular imports was detected: {0} is already on \"importing\" stack", path));
}
projects.OngoingImports.Push(path);
try {
using (var reader = XmlReader.Create(path)) {
var root = ProjectRootElement.Create(reader, projects);
if (DefaultTargets.Count == 0)
{
DefaultTargets.AddRange(GetDefaultTargets(root));
}
raw_imports.Add(new ResolvedImport(import, root, true));
return(this.EvaluatePropertiesAndImports(root.Children).ToArray());
}
} finally {
projects.OngoingImports.Pop();
}
}
public static void SetProperty(Microsoft.Build.Evaluation.Project project, String label, String name, String value)
{
ProjectPropertyGroupElement group = project.Xml.PropertyGroups.FirstOrDefault(g => g.Label.Equals(label));
if (group == null)
{
//
// Create our property group after the main language targets are imported so we can use the properties
// defined in this files.
//
ProjectImportElement import = project.Xml.Imports.FirstOrDefault(
p => (p.Project.IndexOf("Microsoft.Cpp.targets") != -1 || p.Project.IndexOf("IceBuilder.CSharp.props") != -1));
if (import != null)
{
group = project.Xml.CreatePropertyGroupElement();
project.Xml.InsertAfterChild(group, import);
}
else
{
group = project.Xml.CreatePropertyGroupElement();
}
group.Label = label;
}
ProjectPropertyElement property = group.Properties.FirstOrDefault(p => p.Name.Equals(name));
if (property != null)
{
property.Value = value;
}
else
{
group.AddProperty(name, value);
}
}
/// <summary>
/// Add an unresolved regular-style import (i.e. condition is false).
/// </summary>
/// <param name="import">
/// The declaring import element.
/// </param>
void AddUnresolvedImport(ProjectImportElement import)
{
if (import == null)
{
throw new ArgumentNullException(nameof(import));
}
Position importStart = import.Location.ToNative();
XmlLocation importLocation = _projectXmlLocator.Inspect(importStart);
if (importLocation == null)
{
return;
}
XSElement importElement;
if (!importLocation.IsElement(out importElement))
{
return;
}
Add(
new MSBuildUnresolvedImport(import, importElement)
);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResolvedImport"/> struct.
/// </summary>
internal ResolvedImport(Project project, ProjectImportElement importingElement, ProjectRootElement importedProject)
{
ErrorUtilities.VerifyThrowInternalNull(importingElement, "parent");
ErrorUtilities.VerifyThrowInternalNull(importedProject, "child");
_importingElement = importingElement;
_importedProject = importedProject;
_isImported = !ReferenceEquals(project.Xml, importingElement.ContainingProject);
}
/// <param name="element"></param>
public ImportElement(ProjectImportElement element)
: this()
{
parentElement = element ?? throw new ArgumentNullException(nameof(element));
project = element.Project;
condition = element.Condition;
label = element.Label;
}
/// <summary>
/// Add MSBuild Import to the Artifactory project
/// </summary>
private void AddImportToProj()
{
var p = Microsoft.Build.Evaluation.ProjectCollection.GlobalProjectCollection.GetLoadedProjects(_project.FullName).ElementAt(0);
string targetsPath = @"$(solutionDir)\.artifactory\Deploy.targets";
ProjectImportElement import = p.Xml.AddImport(targetsPath);
import.Condition = "Exists('" + targetsPath + "')";
_project.Save();
}
/// <summary>
/// Initializes a new instance of the <see cref="ResolvedImport"/> struct.
/// </summary>
internal ResolvedImport(ProjectImportElement importingElement, ProjectRootElement importedProject, int versionEvaluated, SdkResult sdkResult, bool isImported)
{
ErrorUtilities.VerifyThrowInternalNull(importedProject, "child");
ImportingElement = importingElement;
ImportedProject = importedProject;
SdkResult = sdkResult;
VersionEvaluated = versionEvaluated;
IsImported = isImported;
}
public static void RemoveImport(this MSBuildBasedProject project, string importedProjectFile)
{
lock (project.SyncRoot) {
ProjectImportElement import = project.FindImport(importedProjectFile);
if (import != null)
{
import.Parent.RemoveChild(import);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResolvedImport"/> struct.
/// </summary>
internal ResolvedImport(Project project, ProjectImportElement importingElement, ProjectRootElement importedProject, int versionEvaluated, SdkResult sdkResult)
{
ErrorUtilities.VerifyThrowInternalNull(importedProject, "child");
ImportingElement = importingElement;
ImportedProject = importedProject;
SdkResult = sdkResult;
VersionEvaluated = versionEvaluated;
IsImported = importingElement != null && !ReferenceEquals(project.Xml, importingElement.ContainingProject);
}
public void Merge_MSBuildProjectHasOneImportAndSharpDevelopProjectHasNoImports_MissingImportAddedToSharpDevelopProject()
{
AddImportToMSBuildProject("MyImport.targets");
Merge();
ProjectImportElement import = sharpDevelopProject.MSBuildProjectFile.Imports.FirstOrDefault();
Assert.AreEqual("MyImport.targets", import.Project);
Assert.AreEqual(1, sharpDevelopProject.MSBuildProjectFile.Imports.Count);
}
private static bool UpdateImport(Microsoft.Build.Evaluation.Project project, String oldValue, String newValue)
{
ProjectImportElement import = project.Xml.Imports.FirstOrDefault(p => p.Project.Equals(oldValue));
if (import != null)
{
import.Project = newValue;
import.Condition = String.Format("Exists('{0}')", newValue);
return(true);
}
return(false);
}
public void Merge_MSBuildProjectHasTwoImportsAndSharpDevelopProjectHasOneImportWhichMatchesOneInMSBuildProject_DifferentImportAddedToSharpDevelopProject()
{
AddImportToMSBuildProject("MyImport.targets");
AddImportToMSBuildProject("Different.targets");
AddImportToSharpDevelopProject("MyImport.targets");
Merge();
ProjectImportElement import = sharpDevelopProject.MSBuildProjectFile.Imports.LastOrDefault();
Assert.AreEqual("Different.targets", import.Project);
Assert.AreEqual(2, sharpDevelopProject.MSBuildProjectFile.Imports.Count);
}
private static bool AddImportAfter(Microsoft.Build.Evaluation.Project project,
string import,
ProjectElement after)
{
if (!HasImport(project, import))
{
ProjectImportElement props = project.Xml.CreateImportElement(import);
props.Condition = string.Format("Exists('{0}')", import);
project.Xml.InsertAfterChild(props, after);
return(true);
}
return(false);
}
private static ProjectRootElement CreateBasicProjectStructure()
{
var pre = ProjectRootElement.Create(toolsVersion: "12.0").AddChildren(
ProjectPropertyGroupElement.Create().AddChildren(
ProjectPropertyElement.Create(name: "TargetFrameworkIdentifier", value: ".NETFramework"),
ProjectPropertyElement.Create(name: "TargetFrameworkVersion", value: "v4.5")),
ProjectItemGroupElement.Create().AddChildren(
ProjectItemElement.Create(itemType: "Compile", include: "a.cs"),
ProjectItemElement.Create(itemType: "Compile", include: "b.cs")),
ProjectImportElement.Create(project: "$(MSBuildExtensionsPath32)Microsoft.CSharp.targets"));
return(pre);
}
public void Merge_MSBuildProjectHasOneImportAndSharpDevelopProjectHasTwoImportsOneWhichIsDifferent_DifferentImportRemovedFromSharpDevelopProject()
{
AddImportToMSBuildProject("MyImport.targets");
AddImportToSharpDevelopProject("MyImport.targets");
AddImportToSharpDevelopProject("Different.targets");
Merge();
ProjectImportElement import = sharpDevelopProject.MSBuildProjectFile.Imports.FirstOrDefault();
Assert.AreEqual("MyImport.targets", import.Project);
Assert.AreEqual(1, sharpDevelopProject.MSBuildProjectFile.Imports.Count);
}
private static bool UpdateImport(Microsoft.Build.Evaluation.Project project, string oldValue, string newValue)
{
ProjectImportElement import = project.Xml.Imports.FirstOrDefault(
p => p.Project.Equals(oldValue, StringComparison.CurrentCultureIgnoreCase));
if (import != null)
{
DTEUtil.EnsureFileIsCheckout(project.FullPath);
import.Project = newValue;
import.Condition = string.Format("Exists('{0}')", newValue);
return(true);
}
return(false);
}
private ProjectRootElement ValidateProject(LockFile lockFile, Action <GenerateLockedPackageReferencesFile> modifier, out MockBuildEngine buildEngine)
{
buildEngine = new MockBuildEngine();
GenerateLockedPackageReferencesFile task = new GenerateLockedPackageReferencesFile
{
BuildEngine = buildEngine,
ProjectAssetsFile = GetAssetsFilePath(lockFile),
};
modifier?.Invoke(task);
task.TryCreateProject(out ProjectRootElement project).ShouldBeTrue();
ProjectPropertyGroupElement propertyGroupElement = project.PropertyGroups.ShouldHaveSingleItem();
ProjectPropertyElement propertyElement = propertyGroupElement.Properties.FirstOrDefault(i => i.Name.Equals("NuGetDeterministicPropsWasImported"));
propertyElement.ShouldNotBeNull();
propertyElement.Value.ShouldBe("true");
HashSet <string> excludes = new HashSet <string>(task.PackagesToExclude == null ? Enumerable.Empty <string>() : task.PackagesToExclude.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase);
foreach (TargetFrameworkInformation targetFramework in lockFile.PackageSpec.TargetFrameworks)
{
if (!task.ExcludeImplicitReferences && targetFramework.Dependencies.Any(i => !excludes.Contains(i.Name) && i.AutoReferenced))
{
ProjectPropertyElement disableImplicitFrameworkReferencesPropertyElement = lockFile.PackageSpec.TargetFrameworks.Count > 1 ? project.Properties.FirstOrDefault(i => i.Name.Equals("DisableImplicitFrameworkReferences") && i.Condition.Contains($"'{targetFramework.FrameworkName.GetShortFolderName()}'")) : project.Properties.FirstOrDefault(i => i.Name.Equals("DisableImplicitFrameworkReferences") && i.Condition.Equals(String.Empty));
disableImplicitFrameworkReferencesPropertyElement.ShouldNotBeNull();
}
}
ProjectElement secondElement = project.Children.Skip(1).FirstOrDefault();
ProjectImportElement beforeImportElement = secondElement.ShouldBeOfType <ProjectImportElement>();
beforeImportElement.Project.ShouldBe("Before.$(MSBuildThisFile)");
beforeImportElement.Condition.ShouldBe("Exists('Before.$(MSBuildThisFile)')");
ProjectElement lastElement = project.Children.LastOrDefault();
ProjectImportElement afterImportElement = lastElement.ShouldBeOfType <ProjectImportElement>();
afterImportElement.Project.ShouldBe("After.$(MSBuildThisFile)");
afterImportElement.Condition.ShouldBe("Exists('After.$(MSBuildThisFile)')");
return(project);
}
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();
}
private static void InitializeLegacyProjectImports(ProjectRootElement root)
{
ProjectElement firstChild = root.FirstChild;
ProjectElement lastChild = root.LastChild;
ProjectImportElement commonImport =
root.CreateImportElement("$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props");
commonImport.Condition = "Exists('$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props')";
ProjectImportElement csharpImport =
root.CreateImportElement("$(MSBuildToolsPath)\\Microsoft.CSharp.targets");
root.InsertBeforeChild(commonImport, firstChild);
root.InsertAfterChild(csharpImport, lastChild);
}
public void SetProjectInvalidEmpty()
{
string content = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' >
<Import Project='i1.proj' />
</Project>
";
ProjectRootElement project = ProjectRootElement.Create(XmlReader.Create(new StringReader(content)));
ProjectImportElement import = (ProjectImportElement)Helpers.GetFirst(project.Children);
import.Project = String.Empty;
}
public static bool AddIceBuilderToProject(Microsoft.Build.Evaluation.Project project)
{
bool modified = false;
if (project != null)
{
if (IsCppProject(project))
{
if (!HasImport(project, IceCppPropsPath))
{
ProjectImportElement iceBuilderProps = project.Xml.CreateImportElement(IceCppPropsPath);
ProjectImportElement vcProps = project.Xml.Imports.FirstOrDefault(p => p.Project.IndexOf("Microsoft.Cpp.props") != -1);
project.Xml.InsertAfterChild(iceBuilderProps, vcProps);
modified = true;
}
if (!HasImport(project, IceCppTargetsPath))
{
ProjectImportElement iceBuilderTargets = project.Xml.CreateImportElement(IceCppTargetsPath);
ProjectImportElement vcTargets = project.Xml.Imports.FirstOrDefault(p => p.Project.IndexOf("Microsoft.Cpp.targets") != -1);
project.Xml.InsertAfterChild(iceBuilderTargets, vcTargets);
modified = true;
}
}
else if (IsCSharpProject(project))
{
if (!HasImport(project, IceCSharpPropsPath))
{
ProjectImportElement iceBuilderProps = project.Xml.CreateImportElement(IceCSharpPropsPath);
ProjectImportElement vcProps = project.Xml.Imports.FirstOrDefault(p => p.Project.IndexOf("Microsoft.CSharp.targets") != -1);
project.Xml.InsertAfterChild(iceBuilderProps, vcProps);
modified = true;
}
if (!HasImport(project, IceCSharpTargetsPath))
{
ProjectImportElement iceBuilderTargets = project.Xml.CreateImportElement(IceCSharpTargetsPath);
ProjectImportElement vcTargets = project.Xml.Imports.FirstOrDefault(p => p.Project.IndexOf("IceBuilder.CSharp.props") != -1);
project.Xml.InsertAfterChild(iceBuilderTargets, vcTargets);
modified = true;
}
if (!HasProjectFlavor(project, IceBuilderProjectFlavorGUID))
{
AddProjectFlavorIfNotExists(project, IceBuilderProjectFlavorGUID);
}
}
}
return(modified);
}
