private bool TryGetValueForFrameworkAndFallbacks <TValue>(
IReadOnlyDictionary <NugetTargetFramework, TValue> map,
NugetTargetFramework framework,
out TValue value)
{
if (map.TryGetValue(framework, out value))
{
return(true);
}
return(false);
}
private bool TryGetValueForFrameworkAndFallbacks <TValue>(
IReadOnlyDictionary <NugetTargetFramework, TValue> map,
NugetTargetFramework framework,
out TValue value)
{
if (map.TryGetValue(framework, out value))
{
return(true);
}
if (m_analyzedPackage.NugetFrameworkMonikers.CompatibilityMatrix.TryGetValue(framework.Moniker, out var compatibleFrameworks))
{
foreach (var compatibleFramework in compatibleFrameworks)
{
if (map.TryGetValue(new NugetTargetFramework(compatibleFramework), out value))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Deals with cases like 'lib/portable-net45+win8+wpa81/System.Threading.Tasks.Dataflow.dll'. Splits the compound target framework
/// directory using '-' and '+' as separators and tries to find the first fragment that matches a known target framework.
/// </summary>
/// <remarks>
/// To avoid ambiguity the first framework that gets evaluated and contains a known moniker succeeds, but subsequent
/// compound frameworks that would resolve to the same moniker fail. In that way, the first known framework is mapped to the same moniker and other
/// candidates are ignored.
/// </remarks>
private bool TryGetKnownTargetFramework(PathAtom targetFrameworkFolder, out NugetTargetFramework targetFramework)
{
Contract.Assert(targetFrameworkFolder.IsValid);
var targetFrameworkFragments = targetFrameworkFolder.ToString(m_context.StringTable).Split('+', '-');
// If there are no + or -, then the moniker and the target framework folder are equivalent
// This is the most common case
if (targetFrameworkFragments.Length == 1)
{
if (NugetFrameworkMonikers.WellknownMonikers.Contains(targetFrameworkFolder))
{
// If this is the first time we see this known moniker, we record it
// so no other (compound) target frameworks are used for the same folder
if (!m_monikerToTargetFramework.ContainsKey(targetFrameworkFolder))
{
m_monikerToTargetFramework.Add(targetFrameworkFolder, targetFrameworkFolder);
}
targetFramework = new NugetTargetFramework(targetFrameworkFolder);
return(true);
}
}
foreach (var target in targetFrameworkFragments)
{
if (!PathAtom.TryCreate(m_context.StringTable, target, out Moniker moniker))
{
targetFramework = default(NugetTargetFramework);
return(false);
}
// Check if we saw a compound framework before mapped to the same moniker
if (m_monikerToTargetFramework.ContainsKey(moniker))
{
// We saw it and it's the same target framework folder
if (m_monikerToTargetFramework[moniker] == targetFrameworkFolder)
{
targetFramework = new NugetTargetFramework(moniker, targetFrameworkFolder);
return(true);
}
// We saw it, but the folder is different, so we make it fail
targetFramework = default(NugetTargetFramework);
return(false);
}
// We didn't see this compound framework, so we check if it maps to a known moniker and if
// that's the case we update the compound monikers seen so far and we return it
if (NugetFrameworkMonikers.WellknownMonikers.Contains(moniker))
{
m_monikerToTargetFramework.Add(moniker, targetFrameworkFolder);
targetFramework = new NugetTargetFramework(moniker, targetFrameworkFolder);
return(true);
}
}
targetFramework = default(NugetTargetFramework);
return(false);
}