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);
}
private void InitializeCPSProjectXml()
{
_project = new Project(NewProjectFileOptions.None);
ProjectRootElement root = _project.Xml;
ProjectElement firstChild = root.FirstChild;
ProjectElement lastChild = root.LastChild;
ProjectImportElement sdkPropsImportElement = root.CreateImportElement("Sdk.props");
sdkPropsImportElement.Sdk = "Microsoft.NET.Sdk";
ProjectImportElement sdkTargetsImportElement = root.CreateImportElement("Sdk.targets");
sdkTargetsImportElement.Sdk = "Microsoft.NET.Sdk";
root.InsertBeforeChild(sdkPropsImportElement, firstChild);
root.InsertAfterChild(sdkTargetsImportElement, lastChild);
}
private static void InitializeCPSProjectImports(ProjectRootElement root)
{
ProjectElement firstChild = root.FirstChild;
ProjectElement lastChild = root.LastChild;
ProjectImportElement sdkProps =
root.CreateImportElement("Sdk.props");
sdkProps.Sdk = "Microsoft.NET.Sdk";
ProjectImportElement sdkTargets =
root.CreateImportElement("Sdk.targets");
sdkTargets.Sdk = "Microsoft.NET.Sdk";
root.InsertBeforeChild(sdkProps, firstChild);
root.InsertAfterChild(sdkTargets, lastChild);
}
static ProjectImportElement AddImportAtTop(ProjectRootElement projectRoot, string importedProjectFile)
{
ProjectImportElement import = projectRoot.CreateImportElement(importedProjectFile);
projectRoot.InsertBeforeChild(import, projectRoot.FirstChild);
return(import);
}
private void InitializeLegacyProjectXml()
{
_projectCollection = new ProjectCollection();
_project = new Project(new Dictionary <string, string>(), "12.0", _projectCollection, NewProjectFileOptions.IncludeXmlNamespace | NewProjectFileOptions.IncludeToolsVersion);
ProjectRootElement root = _project.Xml;
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 async Task SetExplicitSdkImportsIfNecessaryAsync(string filePath)
{
XDocument xdoc = XDocument.Load(filePath);
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (xdoc.Root.HasAttributes && xdoc.Root.Attribute("Sdk") != null)
{
xdoc.Root.Attribute("Sdk").Remove();
xdoc.Save(filePath);
ProjectRootElement root = ProjectRootElement.Open(filePath, ProjectCollection, true);
ProjectElement firstChild = root.FirstChild;
ProjectElement lastChild = root.LastChild;
ProjectImportElement sdkPropsImportElement = root.CreateImportElement("Sdk.props");
sdkPropsImportElement.Sdk = "Microsoft.NET.Sdk";
ProjectImportElement sdkTargetsImportElement = root.CreateImportElement("Sdk.targets");
sdkTargetsImportElement.Sdk = "Microsoft.NET.Sdk";
root.InsertBeforeChild(sdkPropsImportElement, firstChild);
root.InsertAfterChild(sdkTargetsImportElement, lastChild);
root.Save(filePath);
}
}
public static ProjectImportElement Clone(this ProjectImportElement oldImport, ProjectRootElement newRoot, ElementLocationOption option = ElementLocationOption.None)
{
ProjectImportElement newImport = newRoot.CreateImportElement(oldImport.Project);
if (!string.IsNullOrEmpty(oldImport.Condition))
{
newImport.Condition = oldImport.Condition;
}
if (!string.IsNullOrEmpty(oldImport.Sdk))
{
newImport.Sdk = oldImport.Sdk;
}
ProcessElementLocationOption(newRoot, option, newImport);
return(newImport);
}
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");
}
/// <summary>
/// Creates an MSBuild properties file that specifies the full closure of packages with locked versions.
/// </summary>
/// <returns>A <see cref="ProjectRootElement"/> object that can be saved.</returns>
internal bool TryCreateProject(out ProjectRootElement project)
{
project = null;
if (!File.Exists(ProjectAssetsFile))
{
Log.LogError($"NuGet assets file '{ProjectAssetsFile}' does not exist.");
return(false);
}
// should item group be conditioned or items or metadata? Perhaps item condition should be considered and compared as well as an item could be conditioned. Consider the below scenarios. Since we are only parsing the assets file we need to consider the project file entries.
// <PackageReference Include="foo" Version="1.2.3" Condition="bar"/>
// <PackageReference Include="foo">
// <version>1.2.3</version>
// <version Condition="bar">1.2.3</version>
// </PackageReference>
// What about dependencies of packages that are conditioned? they should be conditioned as well.
HashSet <string> packagesToExclude = new HashSet <string>(PackagesToExclude?.Select(i => i.ItemSpec).Distinct() ?? Enumerable.Empty <string>(), StringComparer.OrdinalIgnoreCase);
project = ProjectRootElement.Create();
project.ToolsVersion = String.Empty;
ProjectPropertyElement wasImportedPropertyElement = project.AddProperty("NuGetDeterministicPropsWasImported", "true");
LockFile lockFile = LockFileUtilities.GetLockFile(ProjectAssetsFile, NullLogger.Instance);
bool crossTargeting = lockFile.PackageSpec.TargetFrameworks.Count > 1;
foreach (TargetFrameworkInformation targetFramework in lockFile.PackageSpec.TargetFrameworks)
{
HashSet <LockFileLibrary> addedLibraries = new HashSet <LockFileLibrary>();
ProjectItemGroupElement itemGroupElement = project.AddItemGroup();
if (crossTargeting)
{
itemGroupElement.Condition = $" '$(TargetFramework)' == '{targetFramework.FrameworkName.GetShortFolderName()}' ";
}
LockFileTarget target = lockFile.GetTarget(targetFramework.FrameworkName, runtimeIdentifier: null);
bool addedImplicitReference = false;
foreach (LibraryDependency libraryDependency in targetFramework.Dependencies.Where(i => !packagesToExclude.Contains(i.Name)))
{
if (libraryDependency.AutoReferenced)
{
if (ExcludeImplicitReferences)
{
continue;
}
addedImplicitReference = true;
}
LockFileLibrary library = lockFile.GetLibrary(libraryDependency);
if (library.Type.Equals("project", StringComparison.OrdinalIgnoreCase))
{
// if a csproj name matches a package id then nuget swaps in the csproj output instead of the package. Because of this we should skip adding the package as a locked package because it provides no value.
continue;
}
if (addedLibraries.Contains(library))
{
continue;
}
addedLibraries.Add(library);
LockFileTargetLibrary targetLibrary = target.GetTargetLibrary(libraryDependency.Name);
itemGroupElement.AddItem("PackageReference", targetLibrary.Name, GetPackageReferenceItemMetadata(library, libraryDependency));
foreach (LockFileLibrary dependency in targetLibrary.ResolveDependencies(lockFile, target).Where(i => !addedLibraries.Contains(i) && !packagesToExclude.Contains(i.Name)))
{
addedLibraries.Add(dependency);
itemGroupElement.AddItem("PackageReference", dependency.Name, GetPackageReferenceItemMetadata(dependency));
}
}
if (addedImplicitReference)
{
ProjectPropertyElement disableImplicitFrameworkReferencesPropertyElement = project.AddProperty("DisableImplicitFrameworkReferences", "true");
if (crossTargeting)
{
disableImplicitFrameworkReferencesPropertyElement.Condition = $" '$(TargetFramework)' == '{targetFramework.FrameworkName.GetShortFolderName()}' ";
}
}
}
ProjectImportElement beforeImportElement = project.CreateImportElement("Before.$(MSBuildThisFile)");
project.InsertAfterChild(beforeImportElement, wasImportedPropertyElement.Parent);
beforeImportElement.Condition = $"Exists('{beforeImportElement.Project}')";
ProjectImportElement afterImportElement = project.AddImport("After.$(MSBuildThisFile)");
afterImportElement.Condition = $"Exists('{afterImportElement.Project}')";
return(true);
}
