protected void FillClone(ProjectRestoreMetadata clone)
{
clone.ProjectStyle = ProjectStyle;
clone.ProjectPath = ProjectPath;
clone.ProjectJsonPath = ProjectJsonPath;
clone.OutputPath = OutputPath;
clone.ProjectName = ProjectName;
clone.ProjectUniqueName = ProjectUniqueName;
clone.PackagesPath = PackagesPath;
clone.CacheFilePath = CacheFilePath;
clone.CrossTargeting = CrossTargeting;
clone.LegacyPackagesDirectory = LegacyPackagesDirectory;
clone.SkipContentFileWrite = SkipContentFileWrite;
clone.ValidateRuntimeAssets = ValidateRuntimeAssets;
clone.FallbackFolders = FallbackFolders != null ? new List <string>(FallbackFolders) : null;
clone.ConfigFilePaths = ConfigFilePaths != null ? new List <string>(ConfigFilePaths) : null;
clone.OriginalTargetFrameworks = OriginalTargetFrameworks != null ? new List <string>(OriginalTargetFrameworks) : null;
clone.Sources = Sources?.Select(c => c.Clone()).ToList();
clone.TargetFrameworks = TargetFrameworks?.Select(c => c.Clone()).ToList();
clone.Files = Files?.Select(c => c.Clone()).ToList();
clone.ProjectWideWarningProperties = ProjectWideWarningProperties?.Clone();
clone.RestoreLockProperties = RestoreLockProperties?.Clone();
clone.CentralPackageVersionsEnabled = CentralPackageVersionsEnabled;
clone.CentralPackageVersionOverrideDisabled = CentralPackageVersionOverrideDisabled;
clone.CentralPackageTransitivePinningEnabled = CentralPackageTransitivePinningEnabled;
}
public override bool Execute()
{
// We inspect the target frameworks available to find out an appropriate candidate to use for computing the list of
// static web assets for packing.
// Target frameworks have the following pattern {FrameworkIdentifier,FrameworkVersion,PlatformIdentifier?,PlatformVersion?}
// for example: net6.0-windows.10.1980 or net-6.0-ios.14.2.
// We don't deal with any parsing because that's handled by MSBuild. We also don't care about the platform identifier or the
// platform version. The reason is explained below.
// Static web assets don't support having different content based on the target framework. If you are multitargeting (for example,
// in a Razor Class Library) we consider that all TFMs should produce the same set of static web assets and that we can, as a
// result, pick any target framework to act as a representative when we are packing the assets into the package.
// If a package is multitargeting across multiple versions of static web assets, (netstandard2.0 and net6.0 for example) we always
// use as representative the framework with the highest static web assets version (net6.0 in this case).
// Platform identifier and version, don't matter because as mentioned above, the list of assets should be identical in those cases
// and we can pick among any of them to act as a representative for packing purposes.
var selectedFramework = TargetFrameworks
.Select(tf => new FrameworkItem(tf))
.Select(fi => (version: fi.GetStaticWebAssetsVersion(), framework: fi))
.OrderByDescending(p => p.version)
.FirstOrDefault(p => p.version > 0);
EffectiveTargetFramework = selectedFramework.framework?.Moniker;
return(!Log.HasLoggedErrors);
}
public ProjectRestoreMetadata Clone()
{
return(new ProjectRestoreMetadata
{
ProjectStyle = ProjectStyle,
ProjectPath = ProjectPath,
ProjectJsonPath = ProjectJsonPath,
OutputPath = OutputPath,
ProjectName = ProjectName,
ProjectUniqueName = ProjectUniqueName,
PackagesPath = PackagesPath,
CacheFilePath = CacheFilePath,
CrossTargeting = CrossTargeting,
LegacyPackagesDirectory = LegacyPackagesDirectory,
SkipContentFileWrite = SkipContentFileWrite,
ValidateRuntimeAssets = ValidateRuntimeAssets,
FallbackFolders = FallbackFolders != null ? new List <string>(FallbackFolders) : null,
ConfigFilePaths = ConfigFilePaths != null ? new List <string>(ConfigFilePaths) : null,
OriginalTargetFrameworks = OriginalTargetFrameworks != null ? new List <string>(OriginalTargetFrameworks) : null,
Sources = Sources?.Select(c => c.Clone()).ToList(),
TargetFrameworks = TargetFrameworks?.Select(c => c.Clone()).ToList(),
Files = Files?.Select(c => c.Clone()).ToList(),
ProjectWideWarningProperties = ProjectWideWarningProperties?.Clone()
});
}
public ProjectRestoreMetadata Clone()
{
var clonedObject = new ProjectRestoreMetadata();
clonedObject.ProjectStyle = ProjectStyle;
clonedObject.ProjectPath = ProjectPath;
clonedObject.ProjectJsonPath = ProjectJsonPath;
clonedObject.OutputPath = OutputPath;
clonedObject.ProjectName = ProjectName;
clonedObject.ProjectUniqueName = ProjectUniqueName;
clonedObject.PackagesPath = PackagesPath;
clonedObject.CacheFilePath = CacheFilePath;
clonedObject.CrossTargeting = CrossTargeting;
clonedObject.LegacyPackagesDirectory = LegacyPackagesDirectory;
clonedObject.SkipContentFileWrite = SkipContentFileWrite;
clonedObject.ValidateRuntimeAssets = ValidateRuntimeAssets;
clonedObject.FallbackFolders = FallbackFolders != null ? new List <string>(FallbackFolders) : null;
clonedObject.ConfigFilePaths = ConfigFilePaths != null ? new List <string>(ConfigFilePaths) : null;
clonedObject.OriginalTargetFrameworks = OriginalTargetFrameworks != null ? new List <string>(OriginalTargetFrameworks) : null;
clonedObject.Sources = Sources?.Select(c => c.Clone()).ToList();
clonedObject.TargetFrameworks = TargetFrameworks?.Select(c => c.Clone()).ToList();
clonedObject.Files = Files?.Select(c => c.Clone()).ToList();
clonedObject.ProjectWideWarningProperties = ProjectWideWarningProperties?.Clone();
return(clonedObject);
}
public PackageTargetFramework FindClosestTargetFramework(object inputTargetFramework)
{
var moniker = (inputTargetFramework ?? "").ToString().Trim().ToLowerInvariant();
var tf = TargetFrameworks.FirstOrDefault(x => x.Moniker == moniker);
if (tf != null)
{
return(tf);
}
tf = TargetFrameworks.LastOrDefault(x => x.Moniker.StartsWith("netstandard2", StringComparison.Ordinal));
if (tf != null)
{
return(tf);
}
tf = TargetFrameworks.LastOrDefault(x => x.Moniker.StartsWith("netstandard", StringComparison.Ordinal));
if (tf != null)
{
return(tf);
}
tf = TargetFrameworks.LastOrDefault(x => x.Moniker.StartsWith("net", StringComparison.Ordinal));
if (tf != null)
{
return(tf);
}
if (tf == null)
{
tf = TargetFrameworks.FirstOrDefault();
}
return(tf);
}
private bool NeedsReferenceAssemblyPackages()
{
// Check to see if NuGet packages for reference assemblies need to be referenced (because
// the targeting pack is not installed)
bool needsReferenceAssemblyPackages = false;
if (IsSdkProject)
{
foreach (var shortFrameworkName in TargetFrameworks.Split(';').Where(tf => GetShortTargetFrameworkIdentifier(tf) == "net"))
{
// Normalize version to the form used in the reference assemblies path
var version = NuGetFramework.Parse(shortFrameworkName).Version;
version = new Version(version.Major, version.Minor, version.Build);
if (version.Build == 0)
{
version = new Version(version.Major, version.Minor);
}
if (!ReferenceAssembliesAreInstalled(version.ToString()))
{
needsReferenceAssemblyPackages = true;
}
}
}
else
{
needsReferenceAssemblyPackages = !ReferenceAssembliesAreInstalled(TargetFrameworkVersion);
}
return(needsReferenceAssemblyPackages);
}
public override int GetHashCode()
{
var hashCode = new HashCodeCombiner();
hashCode.AddStruct(ProjectStyle);
StringComparer osStringComparer = PathUtility.GetStringComparerBasedOnOS();
if (ProjectPath != null)
{
hashCode.AddObject(osStringComparer.GetHashCode(ProjectPath));
}
if (ProjectJsonPath != null)
{
hashCode.AddObject(osStringComparer.GetHashCode(ProjectJsonPath));
}
if (OutputPath != null)
{
hashCode.AddObject(osStringComparer.GetHashCode(OutputPath));
}
if (ProjectName != null)
{
hashCode.AddObject(osStringComparer.GetHashCode(ProjectName));
}
if (ProjectUniqueName != null)
{
hashCode.AddObject(osStringComparer.GetHashCode(ProjectUniqueName));
}
hashCode.AddSequence(Sources.OrderBy(e => e.Source, StringComparer.OrdinalIgnoreCase));
if (PackagesPath != null)
{
hashCode.AddObject(osStringComparer.GetHashCode(PackagesPath));
}
foreach (var reference in ConfigFilePaths.OrderBy(s => s, osStringComparer))
{
hashCode.AddObject(osStringComparer.GetHashCode(reference));
}
foreach (var reference in FallbackFolders.OrderBy(s => s, osStringComparer))
{
hashCode.AddObject(osStringComparer.GetHashCode(reference));
}
hashCode.AddSequence(TargetFrameworks.OrderBy(dep => dep.TargetAlias, StringComparer.OrdinalIgnoreCase));
foreach (var reference in OriginalTargetFrameworks.OrderBy(s => s, StringComparer.OrdinalIgnoreCase))
{
hashCode.AddObject(StringComparer.OrdinalIgnoreCase.GetHashCode(reference));
}
hashCode.AddObject(CrossTargeting);
hashCode.AddObject(LegacyPackagesDirectory);
hashCode.AddSequence(Files);
hashCode.AddObject(ValidateRuntimeAssets);
hashCode.AddObject(SkipContentFileWrite);
hashCode.AddObject(ProjectWideWarningProperties);
hashCode.AddObject(RestoreLockProperties);
hashCode.AddObject(CentralPackageVersionsEnabled);
hashCode.AddObject(CentralPackageVersionOverrideDisabled);
hashCode.AddObject(CentralPackageTransitivePinningEnabled);
return(hashCode.CombinedHash);
}
private void ParseTargetFrameworks(List <Framework> parsedFrameworkList)
{
string[] Frameworks = TargetFrameworks.Split(';');
foreach (string Framework in Frameworks)
{
ParseTargetFramework(parsedFrameworkList, Framework);
}
}
public void AddFrameworkMonikers(IEnumerable <string> monikers)
{
if (monikers != null)
{
foreach (var moniker in monikers.Distinct())
{
TargetFrameworks.Add(FrameworkNameHelper.ParseFrameworkName(moniker), moniker);
}
}
}
FilePath GetOutputDirectory(DotNetProjectConfiguration configuration)
{
string targetFramework = TargetFrameworks.FirstOrDefault();
FilePath outputDirectory = configuration.OutputDirectory;
if (outputDirectory.IsAbsolute)
{
return(outputDirectory);
}
else if (outputDirectory == "./")
{
outputDirectory = Path.Combine("bin", configuration.Name);
}
return(Project.BaseDirectory.Combine(outputDirectory.ToString(), targetFramework));
}
protected bool InitializeTargetFrameworks()
{
bool add_frameworks(IEnumerable <string> fwStrings)
{
if (fwStrings == null)
{
return(false);
}
foreach (var curFW in fwStrings)
{
//TODO: need to figure out how to determine if it's an app
var newTF = new TargetFramework();
if (!newTF.Initialize(curFW, Logger))
{
return(false);
}
TargetFrameworks.Add(newTF);
}
return(true);
}
TargetFrameworks.Clear();
var singleFramework = ProjectElement.Descendants("TargetFramework").FirstOrDefault()?.Value;
if (singleFramework != null)
{
return(add_frameworks(new[] { singleFramework }));
}
if (!add_frameworks(ProjectElement
.Descendants("TargetFrameworks").FirstOrDefault()?.Value
.Split(';')))
{
return(false);
}
return(true);
}
/// <summary>
/// Returns true if this cross-targeting aggregate project context has the same set of target frameworks and active target framework as the given active and known configurations.
/// </summary>
public bool HasMatchingTargetFrameworks(ProjectConfiguration activeProjectConfiguration,
IReadOnlyCollection <ProjectConfiguration> knownProjectConfigurations)
{
Assumes.True(IsCrossTargeting);
Assumes.True(activeProjectConfiguration.IsCrossTargeting());
Assumes.True(knownProjectConfigurations.All(c => c.IsCrossTargeting()));
ITargetFramework activeTargetFramework = _targetFrameworkProvider.GetTargetFramework(activeProjectConfiguration.Dimensions[ConfigurationGeneral.TargetFrameworkProperty]);
if (!ActiveTargetFramework.Equals(activeTargetFramework))
{
// Active target framework is different.
return(false);
}
var targetFrameworkMonikers = knownProjectConfigurations
.Select(c => c.Dimensions[ConfigurationGeneral.TargetFrameworkProperty])
.Distinct()
.ToList();
if (targetFrameworkMonikers.Count != TargetFrameworks.Length)
{
// Different number of target frameworks.
return(false);
}
foreach (string targetFrameworkMoniker in targetFrameworkMonikers)
{
ITargetFramework targetFramework = _targetFrameworkProvider.GetTargetFramework(targetFrameworkMoniker);
if (!TargetFrameworks.Contains(targetFramework))
{
// Differing TargetFramework
return(false);
}
}
return(true);
}
public override bool Execute()
{
int tfwCount = TargetFrameworks.Length;
MSBuildFileSetResult fileSetResult = new()
{
Projects = WatchFiles
.GroupBy(item => item.GetMetadata("ProjectFullPath"))
.ToDictionary(
group => group.Key,
group => group
.GroupBy(item => item.GetMetadata("FullPath"))
.Select(group => new ProjectFiles
{
FilePath = group.Key,
TargetFrameworks =
/*group.Count() == tfwCount
* ? ""
* :*/string.Join(";", group.Select(group => group.GetMetadata("TFW")))
})
.ToList()),
TargetFrameworks = TargetFrameworks
.Select(item => new TargetFrameworkItem()
{
Name = item.ItemSpec,
Identifier = item.GetMetadata("Identifier"),
Version = item.GetMetadata("Version").Substring(1),
AssemblyPath = item.GetMetadata("Path"),
})
.ToList(),
};
using FileStream fileStream = new(OutputPath.ItemSpec, FileMode.Create, FileAccess.Write, FileShare.None, 1, true);
byte[] json = JsonSerializer.SerializeToUtf8Bytes(fileSetResult);
fileStream.Write(json, 0, json.Length);
return(!Log.HasLoggedErrors);
}
internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
{
string targetFolder = Path.Combine(targetTestAsset.Path, this.Name);
Directory.CreateDirectory(targetFolder);
string targetProjectPath = Path.Combine(targetFolder, this.Name + ".csproj");
string sourceProject;
string sourceProjectBase = Path.Combine(testProjectsSourceFolder, "ProjectConstruction");
if (IsSdkProject)
{
sourceProject = Path.Combine(sourceProjectBase, "SdkProject", "SdkProject.csproj");
}
else
{
sourceProject = Path.Combine(sourceProjectBase, "NetFrameworkProject", "NetFrameworkProject.csproj");
}
var projectXml = XDocument.Load(sourceProject);
var ns = XNamespace.Get("http://schemas.microsoft.com/developer/msbuild/2003");
var propertyGroup = projectXml.Root.Elements(ns + "PropertyGroup").First();
var packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "PackageReference").Count() > 0);
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.First();
}
var targetFrameworks = IsSdkProject ? TargetFrameworks.Split(';') : new[] { "net" };
if (IsSdkProject)
{
if (this.TargetFrameworks.Contains(";"))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworks", this.TargetFrameworks));
}
else
{
propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
}
// If there are any targets that aren't .NET Framework, add appropriate package reference
if (targetFrameworks.Any(identifier => !GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
{
XElement packageReference;
if (this.IsExe)
{
packageReference = new XElement(ns + "PackageReference",
new XAttribute("Include", "Microsoft.NETCore.App"),
new XAttribute("Version", "1.0.1")
);
}
else
{
packageReference = new XElement(ns + "PackageReference",
new XAttribute("Include", "NETStandard.Library"),
new XAttribute("Version", "1.6.0")
);
}
if (targetFrameworks.Any(identifier => GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
{
string condition = null;
foreach (var target in targetFrameworks)
{
if (!GetShortTargetFrameworkIdentifier(target).Equals("net", StringComparison.OrdinalIgnoreCase))
{
if (condition == null)
{
condition = "";
}
else
{
condition += " Or ";
}
condition += $"'$(TargetFramework)' == '{target}'";
}
}
packageReference.SetAttributeValue("Condition", condition);
}
packageReferenceItemGroup.Add(packageReference);
}
if (this.IsExe && targetFrameworks.Any(identifier => GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
{
propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", "win7-x86"));
}
// Update SDK reference to the version under test
projectXml.Descendants(ns + "PackageReference")
.FirstOrDefault(pr => pr.Attribute("Include")?.Value == "Microsoft.NET.Sdk")
?.Element(ns + "Version")
?.SetValue('[' + targetTestAsset.BuildVersion + ']');
}
else
{
var targetFrameworkVersionElement = propertyGroup.Element(ns + "TargetFrameworkVersion");
targetFrameworkVersionElement.SetValue(this.TargetFrameworkVersion);
}
if (this.IsExe)
{
propertyGroup.Element(ns + "OutputType").SetValue("Exe");
}
if (this.ReferencedProjects.Any())
{
var projectReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "ProjectReference").Count() > 0);
if (projectReferenceItemGroup == null)
{
projectReferenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(projectReferenceItemGroup);
}
foreach (var referencedProject in ReferencedProjects)
{
projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
}
}
using (var file = File.CreateText(targetProjectPath))
{
projectXml.Save(file);
}
if (SourceFiles.Count == 0)
{
string source;
if (this.IsExe)
{
source =
@"using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(""Hello World!"");
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.Name);" + Environment.NewLine;
}
source +=
@" }
}";
}
else
{
source =
$@"using System;
namespace {this.Name}
{{
public class {this.Name}Class
{{
public static string Name {{ get {{ return ""{this.Name}""; }} }}
}}
}}";
}
string sourcePath = Path.Combine(targetFolder, this.Name + ".cs");
File.WriteAllText(sourcePath, source);
}
else
{
foreach (var kvp in SourceFiles)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
}
internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
{
string targetFolder = Path.Combine(targetTestAsset.Path, this.Name);
Directory.CreateDirectory(targetFolder);
string targetProjectPath = Path.Combine(targetFolder, this.Name + ".csproj");
string sourceProject;
string sourceProjectBase = Path.Combine(testProjectsSourceFolder, "ProjectConstruction");
if (IsSdkProject)
{
sourceProject = Path.Combine(sourceProjectBase, "SdkProject", "SdkProject.csproj");
}
else
{
sourceProject = Path.Combine(sourceProjectBase, "NetFrameworkProject", "NetFrameworkProject.csproj");
}
// Copy any additional files from template
foreach (var file in Directory.GetFiles(Path.GetDirectoryName(sourceProject)))
{
if (file != sourceProject)
{
File.Copy(file, Path.Combine(targetFolder, Path.GetFileName(file)));
}
}
var projectXml = XDocument.Load(sourceProject);
var ns = projectXml.Root.Name.Namespace;
var propertyGroup = projectXml.Root.Elements(ns + "PropertyGroup").First();
var packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "PackageReference").Count() > 0);
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault();
}
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = new XElement(ns + "ItemGroup");
projectXml.Root.Add(packageReferenceItemGroup);
}
foreach (TestPackageReference packageReference in PackageReferences)
{
var packageReferenceElement = new XElement(ns + "PackageReference",
new XAttribute("Include", packageReference.ID));
if (packageReference.Version != null)
{
packageReferenceElement.Add(new XAttribute("Version", packageReference.Version));
}
if (packageReference.PrivateAssets != null)
{
packageReferenceElement.Add(new XAttribute("PrivateAssets", packageReference.PrivateAssets));
}
packageReferenceItemGroup.Add(packageReferenceElement);
}
foreach (TestPackageReference dotnetCliToolReference in DotNetCliToolReferences)
{
packageReferenceItemGroup.Add(new XElement(ns + "DotNetCliToolReference",
new XAttribute("Include", $"{dotnetCliToolReference.ID}"),
new XAttribute("Version", $"{dotnetCliToolReference.Version}")));
}
// If targeting .NET Framework and a required targeting pack isn't installed, add a
// PackageReference to get the targeting pack from a NuGet package
if (NeedsReferenceAssemblyPackages())
{
packageReferenceItemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", $"Microsoft.NETFramework.ReferenceAssemblies"),
new XAttribute("Version", $"1.0.0-alpha-5")));
propertyGroup.Add(new XElement(ns + "RestoreAdditionalProjectSources", "$(RestoreAdditionalProjectSources);https://dotnet.myget.org/F/roslyn-tools/api/v3/index.json"));
}
var targetFrameworks = IsSdkProject ? TargetFrameworks.Split(';') : new[] { "net" };
if (IsSdkProject)
{
if (this.TargetFrameworks.Contains(";"))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworks", this.TargetFrameworks));
}
else
{
propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
}
if (!string.IsNullOrEmpty(this.RuntimeFrameworkVersion))
{
propertyGroup.Add(new XElement(ns + "RuntimeFrameworkVersion", this.RuntimeFrameworkVersion));
}
if (!string.IsNullOrEmpty(this.RuntimeIdentifier))
{
propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", this.RuntimeIdentifier));
}
}
else
{
if (!string.IsNullOrEmpty(this.TargetFrameworkProfile))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworkProfile", this.TargetFrameworkProfile));
// To construct an accurate PCL project file, we must modify the import of the CSharp targets;
// building/testing the SDK requires a VSDev command prompt which sets 'VSINSTALLDIR'
var importGroup = projectXml.Root.Elements(ns + "Import").Last();
importGroup.Attribute("Project").Value = "$(VSINSTALLDIR)\\MSBuild\\Microsoft\\Portable\\$(TargetFrameworkVersion)\\Microsoft.Portable.CSharp.targets";
}
propertyGroup.Element(ns + "TargetFrameworkVersion").SetValue(this.TargetFrameworkVersion);
}
foreach (var additionalProperty in AdditionalProperties)
{
propertyGroup.Add(new XElement(ns + additionalProperty.Key, additionalProperty.Value));
}
if (AdditionalItems.Any())
{
foreach (var additionalItem in AdditionalItems)
{
var additionalItemGroup = projectXml.Root.Elements(ns + "ItemGroup").FirstOrDefault();
if (additionalItemGroup == null)
{
additionalItemGroup = new XElement(ns + "ItemGroup");
projectXml.Root.Add(packageReferenceItemGroup);
}
additionalItemGroup.Add(new XElement(
ns + additionalItem.Key,
new XAttribute("Include", additionalItem.Value)));
}
}
if (this.IsExe)
{
propertyGroup.Element(ns + "OutputType").SetValue("Exe");
}
if (this.ReferencedProjects.Any())
{
var projectReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "ProjectReference").Count() > 0);
if (projectReferenceItemGroup == null)
{
projectReferenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(projectReferenceItemGroup);
}
foreach (var referencedProject in ReferencedProjects)
{
projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
}
}
if (this.References.Any())
{
var referenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "Reference").Count() > 0);
if (referenceItemGroup == null)
{
referenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(referenceItemGroup);
}
foreach (var reference in References)
{
referenceItemGroup.Add(new XElement(ns + "Reference",
new XAttribute("Include", reference)));
}
}
if (this.CopyFilesTargets.Any())
{
foreach (var copyFilesTarget in CopyFilesTargets)
{
var target = new XElement(ns + "Target",
new XAttribute("Name", copyFilesTarget.TargetName),
new XAttribute("AfterTargets", copyFilesTarget.TargetToRunAfter));
target.Add(new XElement(ns + "Copy",
new XAttribute("SourceFiles", copyFilesTarget.SourceFiles),
new XAttribute("DestinationFolder", copyFilesTarget.Destination)));
projectXml.Root.Add(target);
}
}
using (var file = File.CreateText(targetProjectPath))
{
projectXml.Save(file);
}
if (SourceFiles.Count == 0)
{
string source;
if (this.IsExe)
{
source =
@"using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(""Hello World!"");
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.Name);" + Environment.NewLine;
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.List);" + Environment.NewLine;
}
source +=
@" }
}";
}
else
{
source =
$@"using System;
using System.Collections.Generic;
namespace {this.Name}
{{
public class {this.Name}Class
{{
public static string Name {{ get {{ return ""{this.Name}""; }} }}
public static List<string> List {{ get {{ return null; }} }}
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" public string {dependency.Name}Name {{ get {{ return {dependency.Name}.{dependency.Name}Class.Name; }} }}" + Environment.NewLine;
source += $" public List<string> {dependency.Name}List {{ get {{ return {dependency.Name}.{dependency.Name}Class.List; }} }}" + Environment.NewLine;
}
source +=
@" }
}";
}
string sourcePath = Path.Combine(targetFolder, this.Name + ".cs");
File.WriteAllText(sourcePath, source);
}
else
{
foreach (var kvp in SourceFiles)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
foreach (var kvp in EmbeddedResources)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
public PackageTargetFramework FindExactTargetFramework(string moniker)
{
return(TargetFrameworks.FirstOrDefault(x => x.Moniker == moniker));
}
async Task ReadAsync(HttpClient httpClient, string packageUri)
{
this.Client = httpClient;
var entries = await ReadEntriesAsync(httpClient, packageUri);
TargetFrameworks.Clear();
Content.Clear();
Tools.Clear();
Entry nuspecEntry = null;
foreach (var e in entries.Where(x => Path.GetFileName(x.FullName) != "_._").OrderBy(x => x.FullName))
{
var n = e.FullName;
var isBuild = n.StartsWith("build/", StringComparison.InvariantCultureIgnoreCase);
var isLib = n.StartsWith("lib/", StringComparison.InvariantCultureIgnoreCase);
if ((isBuild || isLib) && (n.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase) ||
n.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase) ||
n.EndsWith(".xml", StringComparison.InvariantCultureIgnoreCase)))
{
var parts = n.Split('/', StringSplitOptions.RemoveEmptyEntries);
string tfm;
if (parts.Length >= 3)
{
tfm = Uri.UnescapeDataString(parts[1].Trim().ToLowerInvariant());
}
else
{
tfm = "net";
}
var tf = TargetFrameworks.FirstOrDefault(x => x.Moniker == tfm);
if (tf == null)
{
tf = new PackageTargetFramework(this, httpClient)
{
Moniker = tfm,
};
TargetFrameworks.Add(tf);
}
if (n.EndsWith(".xml", StringComparison.InvariantCultureIgnoreCase))
{
var docs = new PackageAssemblyXmlLanguageDocs(e);
if (string.IsNullOrEmpty(docs.Error))
{
// System.Console.WriteLine(docs.AssemblyName);
if (!tf.AssemblyXmlDocs.TryGetValue(docs.AssemblyName, out var allLanguageDocs))
{
allLanguageDocs = new PackageAssemblyXmlDocs(docs.AssemblyName);
tf.AssemblyXmlDocs[docs.AssemblyName] = allLanguageDocs;
}
allLanguageDocs.AddLanguage(docs.LanguageCode, docs);
}
}
else if (isBuild)
{
tf.BuildAssemblies.Add(new PackageAssembly(e, tf));
}
else
{
tf.Assemblies.Add(new PackageAssembly(e, tf));
}
}
else if (n.EndsWith(".nuspec", StringComparison.InvariantCultureIgnoreCase))
{
nuspecEntry = e;
}
else if (n.StartsWith("content/", StringComparison.InvariantCultureIgnoreCase))
{
Content.Add(new PackageFile(e));
}
else if (n.StartsWith("tools/", StringComparison.InvariantCultureIgnoreCase))
{
Tools.Add(new PackageFile(e));
}
else
{
// System.Console.WriteLine(e);
}
}
if (nuspecEntry != null)
{
ReadNuspec(nuspecEntry);
}
TargetFrameworks.Sort((a, b) => string.Compare(a.Moniker, b.Moniker, StringComparison.Ordinal));
}
internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
{
string targetFolder = Path.Combine(targetTestAsset.Path, this.Name);
Directory.CreateDirectory(targetFolder);
string targetProjectPath = Path.Combine(targetFolder, this.Name + ".csproj");
string sourceProject;
string sourceProjectBase = Path.Combine(testProjectsSourceFolder, "ProjectConstruction");
if (IsSdkProject)
{
sourceProject = Path.Combine(sourceProjectBase, "SdkProject", "SdkProject.csproj");
}
else
{
sourceProject = Path.Combine(sourceProjectBase, "NetFrameworkProject", "NetFrameworkProject.csproj");
}
var projectXml = XDocument.Load(sourceProject);
var ns = projectXml.Root.Name.Namespace;
var propertyGroup = projectXml.Root.Elements(ns + "PropertyGroup").First();
var packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "PackageReference").Count() > 0);
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault();
}
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = new XElement(ns + "ItemGroup");
projectXml.Root.Add(packageReferenceItemGroup);
}
var targetFrameworks = IsSdkProject ? TargetFrameworks.Split(';') : new[] { "net" };
if (IsSdkProject)
{
if (this.TargetFrameworks.Contains(";"))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworks", this.TargetFrameworks));
}
else
{
propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
}
if (this.IsExe && targetFrameworks.Any(identifier => GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
{
propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", "win7-x86"));
}
// Update SDK reference to the version under test
targetTestAsset.SetSdkVersion(projectXml);
}
else
{
var targetFrameworkVersionElement = propertyGroup.Element(ns + "TargetFrameworkVersion");
targetFrameworkVersionElement.SetValue(this.TargetFrameworkVersion);
}
if (this.IsExe)
{
propertyGroup.Element(ns + "OutputType").SetValue("Exe");
}
if (this.ReferencedProjects.Any())
{
var projectReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "ProjectReference").Count() > 0);
if (projectReferenceItemGroup == null)
{
projectReferenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(projectReferenceItemGroup);
}
foreach (var referencedProject in ReferencedProjects)
{
projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
}
}
using (var file = File.CreateText(targetProjectPath))
{
projectXml.Save(file);
}
if (SourceFiles.Count == 0)
{
string source;
if (this.IsExe)
{
source =
@"using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(""Hello World!"");
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.Name);" + Environment.NewLine;
}
source +=
@" }
}";
}
else
{
source =
$@"using System;
namespace {this.Name}
{{
public class {this.Name}Class
{{
public static string Name {{ get {{ return ""{this.Name}""; }} }}
}}
}}";
}
string sourcePath = Path.Combine(targetFolder, this.Name + ".cs");
File.WriteAllText(sourcePath, source);
}
else
{
foreach (var kvp in SourceFiles)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
}
public bool ShouldSerializeTargetFrameworks()
{
return(!TargetFrameworks.IsNullOrEmpty());
}
public bool IsTransitiveDependency(NuGetReference nugetReference) => TargetFrameworks.Any(tfm => ContainsDependency(tfm, d => ReferenceSatisfiesDependency(d, nugetReference, true)));
private void ParseManagedSemantics()
{
var stringTable = m_context.PathTable.StringTable;
var magicNugetMarker = PathAtom.Create(stringTable, "_._");
var dllExtension = PathAtom.Create(stringTable, ".dll");
foreach (var relativePath in PackageOnDisk.Contents.OrderBy(path => path.ToString(stringTable)))
{
// This is a dll. Check if it is in a lib folder or ref folder.
// This code handles two layouts
// Case 1: /runtimes/{targetRuntime}/[lib|ref]/{targetFramework}/{fileName}
// Case 2: /[lib|ref]/{targetFramework}/{fileName}
// In case 1, /runtimes/{targetRuntime} is removed and then rest of string is processed as in
// case 2.
// Case 2 treats files under 'lib' folder as runtime dependencies (and optionally compile-time
// references if missing a corresponding set of compile-time references for the target framework
// under the 'ref' folder). Files under 'ref' folder are treated strictly as compile-time only references.
var atoms = new ReadOnlySpan <PathAtom>(relativePath.GetAtoms());
if (atoms.Length == 5)
{
var isRuntime = NugetFrameworkMonikers.RuntimesFolderName.CaseInsensitiveEquals(stringTable, atoms[0]) &&
NugetFrameworkMonikers.SupportedTargetRuntimeAtoms.Contains(atoms[1].StringId);
if (isRuntime)
{
atoms = atoms.Slice(2);
}
}
if (atoms.Length == 3)
{
var libOrRef = atoms[0];
var targetFrameworkFolder = atoms[1];
var fileName = atoms[2];
var isLib = NugetFrameworkMonikers.LibFolderName.CaseInsensitiveEquals(stringTable, libOrRef);
var isRef = NugetFrameworkMonikers.RefFolderName.CaseInsensitiveEquals(stringTable, libOrRef);
if (isLib || isRef)
{
if (!TryGetKnownTargetFramework(targetFrameworkFolder, out NugetTargetFramework targetFramework))
{
// We skip unknown frameworks, packages are not necessarily well constructed. We log this
// as a verbose message (i.e., this is not an error).
Logger.Log.NugetUnknownFramework(m_context.LoggingContext, PackageOnDisk.Package.Id,
targetFrameworkFolder.ToString(stringTable), relativePath.ToString(stringTable));
continue;
}
var isManagedEntry = false;
var ext = fileName.GetExtension(stringTable);
if (dllExtension.CaseInsensitiveEquals(stringTable, ext))
{
isManagedEntry = true;
if (isRef)
{
References.Add(targetFramework, relativePath);
}
if (isLib)
{
Libraries.Add(targetFramework, relativePath);
}
}
else if (fileName == magicNugetMarker)
{
isManagedEntry = true;
}
if (isManagedEntry)
{
IsManagedPackage = true;
if (!TargetFrameworks.Contains(targetFramework.Moniker))
{
TargetFrameworks.Add(targetFramework.Moniker);
}
// The magic marker is there so the framework is declared as supported, but no actual files are listed
// So we don't want to add a magic marker as a real artifact that can be referenced.
if (fileName != magicNugetMarker)
{
AssemblyToTargetFramework.Add(fileName, targetFramework);
}
}
}
}
}
if (TargetFrameworks.Count == 0)
{
var history = ForceFullFrameworkQualifiersOnly ?
NugetFrameworkMonikers.FullFrameworkVersionHistory :
NugetFrameworkMonikers.WellknownMonikers.ToList();
foreach (var moniker in history)
{
TargetFrameworks.Add(moniker);
}
}
// For the refs without lib, copy them to refs.
foreach (var kv in Libraries)
{
if (!References.ContainsKey(kv.Key))
{
References.Add(kv.Key, kv.Value.ToArray());
}
}
}
void Read(MemoryStream bytes, HttpClient httpClient)
{
SizeInBytes = bytes.Length;
Archive = new ZipArchive(bytes, ZipArchiveMode.Read);
TargetFrameworks.Clear();
ZipArchiveEntry nuspecEntry = null;
foreach (var e in Archive.Entries.Where(x => x.Name != "_._").OrderBy(x => x.FullName))
{
var n = e.FullName;
var isBuild = n.StartsWith("build/", StringComparison.InvariantCultureIgnoreCase);
var isLib = n.StartsWith("lib/", StringComparison.InvariantCultureIgnoreCase);
if ((isBuild || isLib) && (n.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase) ||
n.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase) ||
n.EndsWith(".xml", StringComparison.InvariantCultureIgnoreCase)))
{
var parts = n.Split('/', StringSplitOptions.RemoveEmptyEntries);
string tfm;
if (parts.Length >= 3)
{
tfm = Uri.UnescapeDataString(parts[1].Trim().ToLowerInvariant());
}
else
{
tfm = "net";
}
var tf = TargetFrameworks.FirstOrDefault(x => x.Moniker == tfm);
if (tf == null)
{
tf = new PackageTargetFramework(this, httpClient)
{
Moniker = tfm,
};
TargetFrameworks.Add(tf);
}
if (n.EndsWith(".xml", StringComparison.InvariantCultureIgnoreCase))
{
var docs = new PackageAssemblyXmlDocs(e);
if (string.IsNullOrEmpty(docs.Error))
{
// System.Console.WriteLine(docs.AssemblyName);
tf.AssemblyXmlDocs[docs.AssemblyName] = docs;
}
}
else if (isBuild)
{
tf.BuildAssemblies.Add(new PackageAssembly(e, tf));
}
else
{
tf.Assemblies.Add(new PackageAssembly(e, tf));
}
}
else if (n.EndsWith(".nuspec", StringComparison.InvariantCultureIgnoreCase))
{
nuspecEntry = e;
}
else if (n.StartsWith("content/", StringComparison.InvariantCultureIgnoreCase))
{
Content.Add(new PackageFile(e));
}
else if (n.StartsWith("tools/", StringComparison.InvariantCultureIgnoreCase))
{
Tools.Add(new PackageFile(e));
}
else
{
// System.Console.WriteLine(e);
}
}
if (nuspecEntry != null)
{
ReadNuspec(nuspecEntry);
}
TargetFrameworks.Sort((a, b) => string.Compare(a.Moniker, b.Moniker, StringComparison.Ordinal));
}
public bool IsTransitivelyAvailable(string packageName) => TargetFrameworks.Any(tfm => ContainsDependency(tfm, d => string.Equals(packageName, d.Id, StringComparison.OrdinalIgnoreCase)));
public async Task <IUpdaterResult> ApplyAsync(IUpgradeContext context, ImmutableArray <IProject> inputs, CancellationToken token)
{
await Task.Yield();
#pragma warning disable CA1031 // Do not catch general exception types
try
{
foreach (var project in inputs)
{
var filePath = project.FindFiles("Package.appxmanifest").FirstOrDefault();
if (string.IsNullOrEmpty(filePath))
{
continue;
}
var doc = new XmlDocument();
doc.Load(filePath);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("def", "http://schemas.microsoft.com/appx/manifest/foundation/windows10");
nsmgr.AddNamespace("mp", "http://schemas.microsoft.com/appx/2014/phone/manifest");
nsmgr.AddNamespace("uap", "http://schemas.microsoft.com/appx/manifest/uap/windows10");
var root = doc.DocumentElement;
var phoneIdentityElement = root.SelectSingleNode("mp:PhoneIdentity", nsmgr);
if (phoneIdentityElement != null)
{
root.RemoveChild(phoneIdentityElement);
}
var appElement = (XmlElement)root.SelectSingleNode("def:Applications/def:Application[@Id]", nsmgr);
appElement.SetAttribute("EntryPoint", "$targetentrypoint$");
var targetDevicesUniversalElement = (XmlElement)root.SelectSingleNode("def:Dependencies/def:TargetDeviceFamily[@Name='Windows.Universal']", nsmgr);
var targetFramework = context.CurrentProject !.TargetFrameworks.FirstOrDefault();
if (targetFramework != null && targetFramework.PlatformVersion != null)
{
var platformVersion = new Version(targetFramework.PlatformVersion.Major == -1 ? 10 : targetFramework.PlatformVersion.Major,
targetFramework.PlatformVersion.Minor == -1 ? 0 : targetFramework.PlatformVersion.Minor,
targetFramework.PlatformVersion.Build == -1 ? 19041 : targetFramework.PlatformVersion.Build,
targetFramework.PlatformVersion.Revision == -1 ? 0 : targetFramework.PlatformVersion.Revision);
targetDevicesUniversalElement.SetAttribute("MaxVersionTested", platformVersion !.ToString());
}
targetDevicesUniversalElement.SetAttribute("Name", "Windows.Desktop");
doc.Save(filePath);
}
}
// Likely to fail while parsing xml if the format does not match the expected format.
// Move on to the next step if it fails
catch (Exception)
{
this._logger.LogError(ErrorMessage);
return(new WindowsDesktopUpdaterResult(
RuleID,
RuleName: Id,
FullDescription: Title,
false,
string.Empty,
new List <string>()));
}
#pragma warning restore CA1031 // Do not catch general exception types
return(new WindowsDesktopUpdaterResult(
RuleID,
RuleName: Id,
FullDescription: Title,
true,
string.Empty,
new List <string>()));
}
/// <summary>
/// Sets a package reference and returns the number of changes.
/// </summary>
/// <param name="m">The monitor.</param>
/// <param name="frameworks">
/// Frameworks that applies to the reference. Must not be empty.
/// Can be this project's <see cref="TargetFrameworks"/> to update the package reference regardless of the framework.
/// </param>
/// <param name="packageId">The package identifier.</param>
/// <param name="version">The new version to set.</param>
/// <param name="addIfNotExists">True to add the reference. By default, it is only updated.</param>
/// <param name="preserveExisting">True to keep any existing version.</param>
/// <param name="throwProjectDependendencies">False to not challenge ProjectReferences.</param>
/// <returns>The number of changes.</returns>
public int SetPackageReferenceVersion(
IActivityMonitor m,
CKTrait frameworks,
string packageId,
SVersion version,
bool addIfNotExists = false,
bool preserveExisting = false,
bool throwProjectDependendencies = true)
{
if (!_dependencies.IsInitialized)
{
throw new InvalidOperationException("Invalid Project.");
}
if (frameworks.IsEmpty)
{
throw new ArgumentException("Must not be empty.", nameof(frameworks));
}
var actualFrameworks = TargetFrameworks.Intersect(frameworks);
if (actualFrameworks.IsEmpty)
{
throw new ArgumentException($"No {frameworks} in {TargetFrameworks}.", nameof(frameworks));
}
if (throwProjectDependendencies && _dependencies.Projects.Any(p => p.TargetProject.ProjectName == packageId))
{
throw new ArgumentException($"Package {packageId} is already a ProjectReference.", nameof(packageId));
}
var sV = version.ToNormalizedString();
int changeCount = 0;
CKTrait pFrameworks = null;
foreach (var p in _dependencies.Packages.Where(p => p.PackageId == packageId &&
!(pFrameworks = p.Frameworks.Intersect(actualFrameworks)).IsEmpty))
{
if (p.VersionLocked)
{
m.Warn($"The version({p.Version}) of the package {packageId} was manually locked. You need to change it manually.");
continue;
}
actualFrameworks = actualFrameworks.Except(pFrameworks);
var currentVersion = p.Version;
if (currentVersion != version)
{
if (!preserveExisting)
{
var e = p.PropertyVersionElement;
if (e != null)
{
e.Value = sV;
}
else
{
e = p.OriginElement;
e.Attribute("Version").SetValue(sV);
}
++changeCount;
m.Trace($"Update in {ToString()}: {packageId} from {currentVersion} to {sV}.");
}
else
{
m.Trace($"Preserving existing version {currentVersion} for {packageId} in {ToString()} (skipped version is {sV}).");
}
}
}
// Handle creation if needed.
if (!actualFrameworks.IsEmpty && addIfNotExists)
{
var firstPropertyGroup = ProjectFile.Document.Root.Element("PropertyGroup");
var pRef = new XElement("ItemGroup",
new XElement("PackageReference",
new XAttribute("Include", packageId),
new XAttribute("Version", sV)));
if (TargetFrameworks == actualFrameworks)
{
++changeCount;
firstPropertyGroup.AddAfterSelf(pRef);
m.Trace($"Added unconditional package reference {packageId} -> {sV} for {ToString()}.");
}
else
{
foreach (var f in actualFrameworks.AtomicTraits)
{
++changeCount;
var withCond = new XElement(pRef);
withCond.SetAttributeValue("Condition", $"'(TargetFrameWork)' == '{f}' ");
firstPropertyGroup.AddAfterSelf(withCond);
m.Trace($"Added conditional {f} package reference {packageId} -> {sV} for {ToString()}.");
}
}
}
if (changeCount > 0)
{
OnChange(m);
}
return(changeCount);
}
internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
{
string targetFolder = Path.Combine(targetTestAsset.Path, this.Name);
Directory.CreateDirectory(targetFolder);
string targetProjectPath = Path.Combine(targetFolder, this.Name + ".csproj");
string sourceProject;
string sourceProjectBase = Path.Combine(testProjectsSourceFolder, "ProjectConstruction");
if (IsSdkProject)
{
sourceProject = Path.Combine(sourceProjectBase, "SdkProject", "SdkProject.csproj");
}
else
{
sourceProject = Path.Combine(sourceProjectBase, "NetFrameworkProject", "NetFrameworkProject.csproj");
}
var projectXml = XDocument.Load(sourceProject);
var ns = projectXml.Root.Name.Namespace;
var propertyGroup = projectXml.Root.Elements(ns + "PropertyGroup").First();
var packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "PackageReference").Count() > 0);
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault();
}
if (packageReferenceItemGroup == null)
{
packageReferenceItemGroup = new XElement(ns + "ItemGroup");
projectXml.Root.Add(packageReferenceItemGroup);
}
foreach (TestPackageReference packageReference in PackageReferences)
{
packageReferenceItemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", $"{packageReference.ID}"),
new XAttribute("Version", $"{packageReference.Version}")));
}
foreach (TestPackageReference dotnetCliToolReference in DotNetCliToolReferences)
{
packageReferenceItemGroup.Add(new XElement(ns + "DotNetCliToolReference",
new XAttribute("Include", $"{dotnetCliToolReference.ID}"),
new XAttribute("Version", $"{dotnetCliToolReference.Version}")));
}
var targetFrameworks = IsSdkProject ? TargetFrameworks.Split(';') : new[] { "net" };
if (IsSdkProject)
{
if (this.TargetFrameworks.Contains(";"))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworks", this.TargetFrameworks));
}
else
{
propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
}
if (!string.IsNullOrEmpty(this.RuntimeFrameworkVersion))
{
propertyGroup.Add(new XElement(ns + "RuntimeFrameworkVersion", this.RuntimeFrameworkVersion));
}
if (!string.IsNullOrEmpty(this.RuntimeIdentifier))
{
propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", this.RuntimeIdentifier));
}
// Update SDK reference to the version under test
targetTestAsset.SetSdkVersion(projectXml);
}
else
{
if (!string.IsNullOrEmpty(this.TargetFrameworkProfile))
{
propertyGroup.Add(new XElement(ns + "TargetFrameworkProfile", this.TargetFrameworkProfile));
// To construct an accurate PCL project file, we must modify the import of the CSharp targets;
// building/testing the SDK requires a VSDev command prompt which sets 'VSINSTALLDIR'
var importGroup = projectXml.Root.Elements(ns + "Import").Last();
importGroup.Attribute("Project").Value = "$(VSINSTALLDIR)\\MSBuild\\Microsoft\\Portable\\$(TargetFrameworkVersion)\\Microsoft.Portable.CSharp.targets";
}
propertyGroup.Element(ns + "TargetFrameworkVersion").SetValue(this.TargetFrameworkVersion);
}
foreach (var additionalProperty in AdditionalProperties)
{
propertyGroup.Add(new XElement(ns + additionalProperty.Key, additionalProperty.Value));
}
if (this.IsExe)
{
propertyGroup.Element(ns + "OutputType").SetValue("Exe");
}
if (this.ReferencedProjects.Any())
{
var projectReferenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "ProjectReference").Count() > 0);
if (projectReferenceItemGroup == null)
{
projectReferenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(projectReferenceItemGroup);
}
foreach (var referencedProject in ReferencedProjects)
{
projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
}
}
if (this.References.Any())
{
var referenceItemGroup = projectXml.Root.Elements(ns + "ItemGroup")
.FirstOrDefault(itemGroup => itemGroup.Elements(ns + "Reference").Count() > 0);
if (referenceItemGroup == null)
{
referenceItemGroup = new XElement(ns + "ItemGroup");
packageReferenceItemGroup.AddBeforeSelf(referenceItemGroup);
}
foreach (var reference in References)
{
referenceItemGroup.Add(new XElement(ns + "Reference",
new XAttribute("Include", reference)));
}
}
using (var file = File.CreateText(targetProjectPath))
{
projectXml.Save(file);
}
if (SourceFiles.Count == 0)
{
string source;
if (this.IsExe)
{
source =
@"using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(""Hello World!"");
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.Name);" + Environment.NewLine;
source += $" Console.WriteLine({dependency.Name}.{dependency.Name}Class.List);" + Environment.NewLine;
}
source +=
@" }
}";
}
else
{
source =
$@"using System;
using System.Collections.Generic;
namespace {this.Name}
{{
public class {this.Name}Class
{{
public static string Name {{ get {{ return ""{this.Name}""; }} }}
public static List<string> List {{ get {{ return null; }} }}
";
foreach (var dependency in this.ReferencedProjects)
{
source += $" public string {dependency.Name}Name {{ get {{ return {dependency.Name}.{dependency.Name}Class.Name; }} }}" + Environment.NewLine;
source += $" public List<string> {dependency.Name}List {{ get {{ return {dependency.Name}.{dependency.Name}Class.List; }} }}" + Environment.NewLine;
}
source +=
@" }
}";
}
string sourcePath = Path.Combine(targetFolder, this.Name + ".cs");
File.WriteAllText(sourcePath, source);
}
else
{
foreach (var kvp in SourceFiles)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
foreach (var kvp in EmbeddedResources)
{
File.WriteAllText(Path.Combine(targetFolder, kvp.Key), kvp.Value);
}
}
private bool Execute(TargetsDefinitions targets)
{
var allTargets = new List <string>();
if (TargetFramework != null)
{
allTargets.Add(TargetFramework.ToString());
}
if (TargetFrameworks != null)
{
allTargets.AddRange(TargetFrameworks.Select(x => x.ToString()));
}
allTargets = allTargets.Distinct().ToList();
// first, check required targets
Log.LogMessage(
MessageImportance.Low,
$"Comparing TargetFramework[s] ({string.Join(";", allTargets)}) to required: {string.Join(",", targets.RequiredTargets.Select(x => x.Name))}.");
foreach (var requiredTarget in targets.RequiredTargets)
{
if (Omitted != null && Omitted.Any(x => x.ToString().Equals(requiredTarget.Name, StringComparison.OrdinalIgnoreCase)))
{
Log.LogMessage(MessageImportance.Low, $"Required TargetFramework '{requiredTarget.Name}' is set to omit.");
continue;
}
if (allTargets.Any(x => x.Equals(requiredTarget.Name, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
var found = requiredTarget.Alternatives?.Any(alternative => allTargets.Contains(alternative));
if (found.GetValueOrDefault(false))
{
continue;
}
Log.LogError(
null,
"CCG0007",
string.Empty,
ProjectFile ?? string.Empty,
0,
0,
0,
0,
"Missing required target: " + requiredTarget.Name);
return(false);
}
// now, check suggested targets
Log.LogMessage(
MessageImportance.Low,
$"Comparing TargetFramework[s] ({string.Join(";", allTargets)}) to suggested: {string.Join(",", targets.SuggestedTargets.Select(x => x.Name))}.");
foreach (var suggestedTarget in targets.SuggestedTargets)
{
if (Omitted != null && Omitted.Any(x => x.ToString().Equals(suggestedTarget.Name, StringComparison.OrdinalIgnoreCase)))
{
Log.LogMessage(MessageImportance.Low, $"Suggested TargetFramework '{suggestedTarget.Name}' is set to omit.");
continue;
}
if (allTargets.Any(x => x.Equals(suggestedTarget.Name, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
var found = suggestedTarget.Alternatives?.Any(alternative => allTargets.Contains(alternative));
if (found.GetValueOrDefault(false))
{
continue;
}
Log.LogWarning(
null,
"CCG0007",
string.Empty,
ProjectFile ?? string.Empty,
0,
0,
0,
0,
"Missing suggested target: " + suggestedTarget.Name);
}
return(true);
}
/// <nodoc />
private bool TryParseDependenciesFromNuSpec(XDocument nuSpec)
{
var dependencyNodes = nuSpec
.Elements()
.Where(el => string.Equals(el.Name.LocalName, "package", StringComparison.Ordinal))
.Elements()
.Where(el => string.Equals(el.Name.LocalName, "metadata", StringComparison.Ordinal))
.Elements()
.Where(el => string.Equals(el.Name.LocalName, "dependencies", StringComparison.Ordinal))
.Elements();
// Namespace independent query, nuget has about 6 different namespaces as of may 2016.
var skipIdLookupTable = new HashSet <string>(DependentPackageIdsToSkip);
var ignoreIdLookupTable = new HashSet <string>(DependentPackageIdsToIgnore);
bool skipAllDependencies = skipIdLookupTable.Contains("*");
bool ignoreAllDependencies = ignoreIdLookupTable.Contains("*");
foreach (var dependency in dependencyNodes.Where(el => string.Equals(el.Name.LocalName, "dependency", StringComparison.Ordinal)))
{
var genericDependency = ReadDependencyElement(dependency);
if (genericDependency == null && !(ignoreAllDependencies || ignoreIdLookupTable.Contains(dependency.Attribute("id")?.Value?.Trim())))
{
return(false);
}
if (genericDependency != null && !skipAllDependencies && !skipIdLookupTable.Contains(genericDependency.GetPackageIdentity()))
{
m_dependencies.Add(genericDependency);
}
}
var groups = dependencyNodes.Where(el => string.Equals(el.Name.LocalName, "group", StringComparison.Ordinal));
foreach (var group in groups)
{
if (group.Attribute("targetFramework") != null && NugetFrameworkMonikers.TargetFrameworkNameToMoniker.TryGetValue(group.Attribute("targetFramework").Value, out Moniker targetFramework))
{
if (group.Elements().Any())
{
// If there is at least one valid dependency for a known framework, then the package is defined as managed
IsManagedPackage = true;
// Only add the group dependency target framework if the nuget package itself also contains specific assemblies of the same version
if (!TargetFrameworks.Contains(targetFramework) && (References.Keys.Any(tfm => tfm.Moniker == targetFramework) || Libraries.Keys.Any(tfm => tfm.Moniker == targetFramework)))
{
TargetFrameworks.Add(targetFramework);
}
// If the package has a pinned tfm and the groups tfm does not match, skip the groups dependency resolution
if (!string.IsNullOrEmpty(this.Tfm) && NugetFrameworkMonikers.TargetFrameworkNameToMoniker.TryGetValue(this.Tfm, out Moniker pinnedTfm) && !PathAtom.Equals(pinnedTfm, targetFramework))
{
continue;
}
foreach (
var dependency in
group.Elements().Where(
el => string.Equals(el.Name.LocalName, "dependency", StringComparison.Ordinal)))
{
var grouppedDependency = ReadDependencyElement(dependency);
if (grouppedDependency == null && !(ignoreAllDependencies || ignoreIdLookupTable.Contains(dependency.Attribute("id")?.Value?.Trim())))
{
return(false);
}
if (grouppedDependency != null && !skipAllDependencies && !skipIdLookupTable.Contains(grouppedDependency.GetPackageIdentity()))
{
DependenciesPerFramework.Add(targetFramework, grouppedDependency);
}
}
}
}
}
IsNetStandardPackageOnly =
!TargetFrameworks.Any(tfm => NugetFrameworkMonikers.FullFrameworkVersionHistory.Contains(tfm)) &&
!TargetFrameworks.Any(tfm => NugetFrameworkMonikers.NetCoreAppVersionHistory.Contains(tfm));
return(true);
}
private void ParseManagedSemantics()
{
var stringTable = m_context.PathTable.StringTable;
var magicNugetMarker = PathAtom.Create(stringTable, "_._");
var dllExtension = PathAtom.Create(stringTable, ".dll");
var refs = new MultiValueDictionary <NugetTargetFramework, RelativePath>();
var libs = new MultiValueDictionary <NugetTargetFramework, RelativePath>();
var assemblyToTargetFramework = new MultiValueDictionary <PathAtom, NugetTargetFramework>();
foreach (var relativePath in PackageOnDisk.Contents.OrderBy(path => path.ToString(stringTable)))
{
// This is a dll. Check if it is in a lib folder or ref folder.
var atoms = relativePath.GetAtoms();
if (atoms.Length == 3)
{
var libOrRef = atoms[0];
var targetFrameworkFolder = atoms[1];
var fileName = atoms[2];
var isLib = NugetFrameworkMonikers.LibFolderName.CaseInsensitiveEquals(stringTable, libOrRef);
var isRef = NugetFrameworkMonikers.RefFolderName.CaseInsensitiveEquals(stringTable, libOrRef);
if (isLib || isRef)
{
if (!TryGetKnownTargetFramework(targetFrameworkFolder, out NugetTargetFramework targetFramework))
{
// We skip unknown frameworks, packages are not necessarily well constructed. We log this
// as a verbose message (i.e., this is not an error).
Logger.Log.NugetUnknownFramework(m_context.LoggingContext, PackageOnDisk.Package.Id,
targetFrameworkFolder.ToString(stringTable), relativePath.ToString(stringTable));
continue;
}
var isManagedEntry = false;
var ext = fileName.GetExtension(stringTable);
if (dllExtension.CaseInsensitiveEquals(stringTable, ext))
{
isManagedEntry = true;
if (isRef)
{
refs.Add(targetFramework, relativePath);
}
if (isLib)
{
libs.Add(targetFramework, relativePath);
}
}
else if (fileName == magicNugetMarker)
{
isManagedEntry = true;
}
if (isManagedEntry)
{
IsManagedPackage = true;
if (!TargetFrameworks.Contains(targetFramework.Moniker))
{
TargetFrameworks.Add(targetFramework.Moniker);
}
// The magic marker is there so the framework is declared as supported, but no actual files are listed
// So we don't want to add a magic marker as a real artifact that can be referenced.
if (fileName != magicNugetMarker)
{
assemblyToTargetFramework.Add(fileName, targetFramework);
}
}
}
}
}
if (TargetFrameworks.Count == 0)
{
var history = ForceFullFrameworkQualifiersOnly ?
NugetFrameworkMonikers.FullFrameworkVersionHistory :
NugetFrameworkMonikers.WellknownMonikers.ToList();
foreach (var moniker in history)
{
TargetFrameworks.Add(moniker);
}
}
// For the refs without lib, copy them to refs.
foreach (var kv in libs)
{
if (!refs.ContainsKey(kv.Key))
{
refs.Add(kv.Key, kv.Value.ToArray());
}
}
References = refs;
Libraries = libs;
AssemblyToTargetFramework = assemblyToTargetFramework;
}
public XElement CreateRootElement()
{
return(new XElement("Project", new XAttribute("Sdk", Sdk),
new XElement("PropertyGroup",
new XElement(TargetFrameworks.Count > 1 ? "TargetFrameworks" : "TargetFramework", TargetFrameworks.Aggregate((a, b) => a + ';' + b)),
OutputType != null ? new XElement("OutputType", OutputType) : null,
LangVersion != null ? new XElement("LangVersion", LangVersion) : null,
new XElement("AssemblyName", ProjectName)),
new XElement("ItemGroup",
UnifiedPackageReferences.Select(p => new XElement("PackageReference",
new XAttribute("Include", p.Name),
new XAttribute("Version", p.Version))))));
}
