private bool KnownFrameworkReferenceAppliesToTargetFramework(KnownFrameworkReference kfr)
{
if (!kfr.TargetFramework.Framework.Equals(TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) ||
NormalizeVersion(kfr.TargetFramework.Version) != _normalizedTargetFrameworkVersion)
{
return(false);
}
if (!string.IsNullOrEmpty(kfr.TargetFramework.Platform) &&
kfr.TargetFramework.PlatformVersion != null)
{
if (!Version.TryParse(TargetPlatformVersion, out var targetPlatformVersionParsed))
{
return(false);
}
if (NormalizeVersion(targetPlatformVersionParsed) != NormalizeVersion(kfr.TargetFramework.PlatformVersion) ||
NormalizeVersion(kfr.TargetFramework.Version) != _normalizedTargetFrameworkVersion)
{
return(false);
}
}
return(true);
}
private void ProcessRuntimeIdentifier(string runtimeIdentifier, KnownFrameworkReference knownFrameworkReference,
string runtimeFrameworkVersion, HashSet <string> unrecognizedRuntimeIdentifiers,
List <ITaskItem> unavailableRuntimePacks, List <ITaskItem> runtimePacks, List <ITaskItem> packagesToDownload, string isTrimmable)
{
var runtimeGraph = new RuntimeGraphCache(this).GetRuntimeGraph(RuntimeGraphPath);
var knownFrameworkReferenceRuntimePackRuntimeIdentifiers = knownFrameworkReference.RuntimePackRuntimeIdentifiers.Split(';');
string runtimePackRuntimeIdentifier = NuGetUtils.GetBestMatchingRid(
runtimeGraph,
runtimeIdentifier,
knownFrameworkReferenceRuntimePackRuntimeIdentifiers,
out bool wasInGraph);
if (runtimePackRuntimeIdentifier == null)
{
if (wasInGraph)
{
// Report this as an error later, if necessary. This is because we try to download
// all available runtime packs in case there is a transitive reference to a shared
// framework we don't directly reference. But we don't want to immediately error out
// here if a runtime pack that we might not need to reference isn't available for the
// targeted RID (e.g. Microsoft.WindowsDesktop.App for a linux RID).
var unavailableRuntimePack = new TaskItem(knownFrameworkReference.Name);
unavailableRuntimePack.SetMetadata(MetadataKeys.RuntimeIdentifier, runtimeIdentifier);
unavailableRuntimePacks.Add(unavailableRuntimePack);
}
else if (!unrecognizedRuntimeIdentifiers.Contains(runtimeIdentifier))
{
// NETSDK1083: The specified RuntimeIdentifier '{0}' is not recognized.
Log.LogError(Strings.RuntimeIdentifierNotRecognized, runtimeIdentifier);
unrecognizedRuntimeIdentifiers.Add(runtimeIdentifier);
}
}
else
{
foreach (var runtimePackNamePattern in knownFrameworkReference.RuntimePackNamePatterns.Split(';'))
{
string runtimePackName = runtimePackNamePattern.Replace("**RID**", runtimePackRuntimeIdentifier);
if (runtimePacks != null)
{
TaskItem runtimePackItem = new TaskItem(runtimePackName);
runtimePackItem.SetMetadata(MetadataKeys.PackageName, runtimePackName);
runtimePackItem.SetMetadata(MetadataKeys.PackageVersion, runtimeFrameworkVersion);
runtimePackItem.SetMetadata(MetadataKeys.FrameworkName, knownFrameworkReference.Name);
runtimePackItem.SetMetadata(MetadataKeys.RuntimeIdentifier, runtimePackRuntimeIdentifier);
runtimePackItem.SetMetadata(MetadataKeys.IsTrimmable, isTrimmable);
runtimePackItem.SetMetadata(MetadataKeys.AvailableRuntimeIdentifiers, knownFrameworkReference.RuntimePackRuntimeIdentifiers);
runtimePacks.Add(runtimePackItem);
}
TaskItem packageToDownload = new TaskItem(runtimePackName);
packageToDownload.SetMetadata(MetadataKeys.Version, runtimeFrameworkVersion);
packagesToDownload.Add(packageToDownload);
}
}
}
private string GetRuntimeFrameworkVersion(
ITaskItem frameworkReference,
KnownFrameworkReference knownFrameworkReference,
KnownRuntimePack?knownRuntimePack,
out string runtimePackVersion)
{
// Precedence order for selecting runtime framework version
// - RuntimeFrameworkVersion metadata on FrameworkReference item
// - RuntimeFrameworkVersion MSBuild property
// - Then, use either the LatestRuntimeFrameworkVersion or the DefaultRuntimeFrameworkVersion of the KnownFrameworkReference, based on
// - The value (if set) of TargetLatestRuntimePatch metadata on the FrameworkReference
// - The TargetLatestRuntimePatch MSBuild property (which defaults to True if SelfContained is true, and False otherwise)
// - But, if TargetLatestRuntimePatch was defaulted and not overridden by user, then acquire latest runtime pack for future
// self-contained deployment (or for crossgen of framework-dependent deployment), while targeting the default version.
string requestedVersion = GetRequestedRuntimeFrameworkVersion(frameworkReference);
if (!string.IsNullOrEmpty(requestedVersion))
{
runtimePackVersion = requestedVersion;
return(requestedVersion);
}
switch (GetRuntimePatchRequest(frameworkReference))
{
case RuntimePatchRequest.UseDefaultVersion:
runtimePackVersion = knownFrameworkReference.DefaultRuntimeFrameworkVersion;
return(knownFrameworkReference.DefaultRuntimeFrameworkVersion);
case RuntimePatchRequest.UseLatestVersion:
if (knownRuntimePack != null)
{
runtimePackVersion = knownRuntimePack?.LatestRuntimeFrameworkVersion;
return(knownRuntimePack?.LatestRuntimeFrameworkVersion);
}
else
{
runtimePackVersion = knownFrameworkReference.DefaultRuntimeFrameworkVersion;
return(knownFrameworkReference.DefaultRuntimeFrameworkVersion);
}
case RuntimePatchRequest.UseDefaultVersionWithLatestRuntimePack:
if (knownRuntimePack != null)
{
runtimePackVersion = knownRuntimePack?.LatestRuntimeFrameworkVersion;
}
else
{
runtimePackVersion = knownFrameworkReference.DefaultRuntimeFrameworkVersion;
}
return(knownFrameworkReference.DefaultRuntimeFrameworkVersion);
default:
// Unreachable
throw new InvalidOperationException();
}
}
private string GetRuntimeFrameworkVersion(ITaskItem frameworkReference, KnownFrameworkReference knownFrameworkReference)
{
// Precedence order for selecting runtime framework version
// - RuntimeFrameworkVersion metadata on FrameworkReference item
// - RuntimeFrameworkVersion MSBuild property
// - Then, use either the LatestRuntimeFrameworkVersion or the DefaultRuntimeFrameworkVersion of the KnownFrameworkReference, based on
// - The value (if set) of TargetLatestRuntimePatch metadata on the FrameworkReference
// - The TargetLatestRuntimePatch MSBuild property (which defaults to True if SelfContained is true, and False otherwise)
string runtimeFrameworkVersion = null;
if (frameworkReference != null)
{
runtimeFrameworkVersion = frameworkReference.GetMetadata("RuntimeFrameworkVersion");
}
if (string.IsNullOrEmpty(runtimeFrameworkVersion))
{
runtimeFrameworkVersion = RuntimeFrameworkVersion;
}
if (string.IsNullOrEmpty(runtimeFrameworkVersion))
{
bool?useLatestRuntimeFrameworkVersion = null;
if (frameworkReference != null)
{
string useLatestRuntimeFrameworkMetadata = frameworkReference.GetMetadata("TargetLatestRuntimePatch");
if (!string.IsNullOrEmpty(useLatestRuntimeFrameworkMetadata))
{
useLatestRuntimeFrameworkVersion = MSBuildUtilities.ConvertStringToBool(useLatestRuntimeFrameworkMetadata,
defaultValue: false);
}
}
if (useLatestRuntimeFrameworkVersion == null)
{
useLatestRuntimeFrameworkVersion = TargetLatestRuntimePatch;
}
if (useLatestRuntimeFrameworkVersion.Value)
{
runtimeFrameworkVersion = knownFrameworkReference.LatestRuntimeFrameworkVersion;
}
else
{
runtimeFrameworkVersion = knownFrameworkReference.DefaultRuntimeFrameworkVersion;
}
}
return(runtimeFrameworkVersion);
}
private KnownRuntimePack?SelectRuntimePack(ITaskItem frameworkReference, KnownFrameworkReference knownFrameworkReference, List <KnownRuntimePack> knownRuntimePacks)
{
var requiredLabelsMetadata = frameworkReference?.GetMetadata(MetadataKeys.RuntimePackLabels) ?? "";
HashSet <string> requiredRuntimePackLabels = null;
if (frameworkReference != null)
{
requiredRuntimePackLabels = new HashSet <string>(requiredLabelsMetadata.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries), StringComparer.OrdinalIgnoreCase);
}
// The runtime pack name matches the RuntimeFrameworkName on the KnownFrameworkReference
var matchingRuntimePacks = knownRuntimePacks.Where(krp => krp.Name.Equals(knownFrameworkReference.RuntimeFrameworkName, StringComparison.OrdinalIgnoreCase))
.Where(krp =>
{
if (requiredRuntimePackLabels == null)
{
return(krp.RuntimePackLabels.Length == 0);
}
else
{
return(requiredRuntimePackLabels.SetEquals(krp.RuntimePackLabels));
}
})
.ToList();
if (matchingRuntimePacks.Count == 0)
{
return(null);
}
else if (matchingRuntimePacks.Count == 1)
{
return(matchingRuntimePacks[0]);
}
else
{
string runtimePackDescriptionForErrorMessage = knownFrameworkReference.RuntimeFrameworkName +
(requiredLabelsMetadata == string.Empty ? string.Empty : ":" + requiredLabelsMetadata);
Log.LogError(Strings.ConflictingRuntimePackInformation, runtimePackDescriptionForErrorMessage,
string.Join(Environment.NewLine, matchingRuntimePacks.Select(rp => rp.RuntimePackNamePatterns)));
return(knownFrameworkReference.ToKnownRuntimePack());
}
}
