/// <summary>
/// Find the most compatible group based on target framework
/// </summary>
/// <param name="items">framework specific groups or items</param>
/// <param name="framework">project target framework</param>
public static T GetNearest <T>(IEnumerable <T> items,
NuGetFramework framework,
IFrameworkNameProvider frameworkMappings,
IFrameworkCompatibilityProvider compatibilityProvider) where T : IFrameworkSpecific
{
if (framework == null)
{
throw new ArgumentNullException(nameof(framework));
}
if (frameworkMappings == null)
{
throw new ArgumentNullException(nameof(frameworkMappings));
}
if (compatibilityProvider == null)
{
throw new ArgumentNullException(nameof(compatibilityProvider));
}
if (items != null)
{
var reducer = new FrameworkReducer(frameworkMappings, compatibilityProvider);
var mostCompatibleFramework = reducer.GetNearest(framework, items.Select(item => item.TargetFramework));
if (mostCompatibleFramework != null)
{
return(items.FirstOrDefault(item => NuGetFramework.Comparer.Equals(item.TargetFramework, mostCompatibleFramework)));
}
}
return(default(T));
}
public CompatibilityTable(IEnumerable<NuGetFramework> frameworks, IFrameworkNameProvider mappings, IFrameworkCompatibilityProvider compat)
{
_compat = compat;
_mappings = mappings;
_table = GetTable(frameworks, _mappings, _compat);
_reducer = new FrameworkReducer(_mappings, _compat);
}
/// <summary>
/// Creates a FrameworkReducer using custom framework mappings.
/// </summary>
public FrameworkReducer(IFrameworkNameProvider mappings, IFrameworkCompatibilityProvider compat)
{
_mappings = mappings;
_compat = compat;
_fullComparer = new NuGetFrameworkFullComparer();
_fwNameComparer = new NuGetFrameworkNameComparer();
}
/// <summary>
/// Creates a FrameworkReducer using custom framework mappings.
/// </summary>
public FrameworkReducer(IFrameworkNameProvider mappings, IFrameworkCompatibilityProvider compat)
{
_mappings = mappings;
_compat = compat;
_fullComparer = new NuGetFrameworkFullComparer();
_fwNameComparer = new NuGetFrameworkNameComparer();
}
/// <summary>
/// Возвращает список совместимых элементов.
/// </summary>
/// <param name="reader">Интерфейс для чтения метаданных пакета.</param>
/// <param name="items">Список элементов для выборки.</param>
/// <param name="targetFramework">Версия совместимого фреймворка.</param>
/// <param name="compatibilityProvider">Провайдер для проверки совместимости фреймворков.</param>
private static FrameworkSpecificGroup GetCompatibleItems(PackageReaderBase reader,
IList <FrameworkSpecificGroup> items,
NuGetFramework targetFramework,
IFrameworkCompatibilityProvider compatibilityProvider)
{
// Из пакета выбираются файлы с TargetFramework, который
// является наиболее новым и совместимым с указанным
var compatibleItems = items
.OrderByDescending(i => i.TargetFramework, NuGetFrameworkComparer)
.FirstOrDefault(i => NuGetFrameworkComparer.Compare(i.TargetFramework, targetFramework) <= 0 &&
compatibilityProvider.IsCompatible(targetFramework, i.TargetFramework));
if (compatibleItems == null)
{
var portableFramework = reader.GetSupportedFrameworks()
.FirstOrDefault(i => string.Equals(i.Framework, FrameworkConstants.FrameworkIdentifiers.NetPlatform, StringComparison.OrdinalIgnoreCase));
if (portableFramework != null && compatibilityProvider.IsCompatible(targetFramework, portableFramework))
{
compatibleItems = items.FirstOrDefault(i => NuGetFrameworkComparer.Compare(i.TargetFramework, portableFramework) == 0);
}
}
if (compatibleItems == null)
{
// TODO Update Nuget packages, add .NETStandard compability
compatibleItems = items.FirstOrDefault(i => i.TargetFramework.DotNetFrameworkName.Contains(FrameworkConstants.FrameworkIdentifiers.NetStandard));
}
return(compatibleItems);
}
/// <summary>
/// Find the most compatible group based on target framework
/// </summary>
/// <param name="items">framework specific groups or items</param>
/// <param name="framework">project target framework</param>
/// <param name="selector">retrieves the framework from the group</param>
/// <param name="frameworkMappings">framework mappings</param>
public static T GetNearest <T>(IEnumerable <T> items,
NuGetFramework framework,
IFrameworkNameProvider frameworkMappings,
IFrameworkCompatibilityProvider compatibilityProvider,
Func <T, NuGetFramework> selector) where T : class
{
if (framework == null)
{
throw new ArgumentNullException("framework");
}
if (frameworkMappings == null)
{
throw new ArgumentNullException("frameworkMappings");
}
if (compatibilityProvider == null)
{
throw new ArgumentNullException("compatibilityProvider");
}
if (items != null)
{
var reducer = new FrameworkReducer(frameworkMappings, compatibilityProvider);
var mostCompatibleFramework = reducer.GetNearest(framework, items.Select(selector));
if (mostCompatibleFramework != null)
{
return(items.FirstOrDefault(item => NuGetFramework.Comparer.Equals(selector(item), mostCompatibleFramework)));
}
}
return(null);
}
public CompatibilityTable(IEnumerable <NuGetFramework> frameworks, IFrameworkNameProvider mappings, IFrameworkCompatibilityProvider compat)
{
_compat = compat;
_mappings = mappings;
_table = GetTable(frameworks, _mappings, _compat);
_reducer = new FrameworkReducer(_mappings, _compat);
}
/// <summary>
/// Nupkg package reader
/// </summary>
/// <param name="zipArchive">ZipArchive containing the nupkg data.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
/// <param name="compatibilityProvider">Framework compatibility provider.</param>
public PackageReader(ZipArchive zipArchive, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: base(frameworkProvider, compatibilityProvider)
{
if (zipArchive == null)
{
throw new ArgumentNullException(nameof(zipArchive));
}
_zip = zipArchive;
}
/// <summary>
/// Instantiates a new <see cref="PackageReaderBase" /> class.
/// </summary>
/// <param name="frameworkProvider">A framework mapping provider.</param>
/// <param name="compatibilityProvider">A framework compatibility provider.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="frameworkProvider" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="compatibilityProvider" /> is <c>null</c>.</exception>
public PackageReaderBase(IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
{
if (frameworkProvider == null)
{
throw new ArgumentNullException(nameof(frameworkProvider));
}
if (compatibilityProvider == null)
{
throw new ArgumentNullException(nameof(compatibilityProvider));
}
FrameworkProvider = frameworkProvider;
CompatibilityProvider = compatibilityProvider;
}
/// <summary>
/// Core package reader
/// </summary>
/// <param name="frameworkProvider">framework mapping provider</param>
/// <param name="compatibilityProvider">framework compatibility provider</param>
public PackageReaderBase(IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: base()
{
if (frameworkProvider == null)
{
throw new ArgumentNullException(nameof(frameworkProvider));
}
if (compatibilityProvider == null)
{
throw new ArgumentNullException(nameof(compatibilityProvider));
}
_frameworkProvider = frameworkProvider;
_compatibilityProvider = compatibilityProvider;
}
/// <summary>
/// Добавляет в содержимое пакета совместимые версии файлов из указанного пакета.
/// </summary>
/// <param name="packageContent">Содержимое пакета.</param>
/// <param name="packageIdentity">Идентификатор пакета.</param>
/// <param name="targetFramework">Версия совместимого фреймворка.</param>
/// <param name="compatibilityProvider">Провайдер для проверки совместимости фреймворков.</param>
private void FillPackageContent(PackageContent packageContent,
PackageIdentity packageIdentity,
NuGetFramework targetFramework,
IFrameworkCompatibilityProvider compatibilityProvider)
{
var packagePath = GetPackagePath(packageIdentity);
using (var reader = new PackageFolderReader(packagePath))
{
var libItems = GetCompatibleItems(reader, reader.GetLibItems().ToList(), targetFramework, compatibilityProvider);
if (libItems?.Items != null)
{
foreach (var item in libItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PackagingConstants.Folders.Lib, libItems.TargetFramework);
packageContent.Lib.Add(installItem);
}
}
var contentItems = GetCompatibleItems(reader, reader.GetContentItems().ToList(), targetFramework, compatibilityProvider);
if (contentItems?.Items != null)
{
foreach (var item in contentItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PackagingConstants.Folders.Content, contentItems.TargetFramework);
packageContent.Content.Add(installItem);
}
}
var pluginItems = GetCompatibleItems(reader, reader.GetPluginItems().ToList(), targetFramework, compatibilityProvider);
if (pluginItems?.Items != null)
{
foreach (var item in pluginItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PluginFolderName, pluginItems.TargetFramework);
packageContent.Plugin.Add(installItem);
}
}
}
}
private static Dictionary<NuGetFramework, HashSet<NuGetFramework>> GetTable(IEnumerable<NuGetFramework> frameworks, IFrameworkNameProvider mappings, IFrameworkCompatibilityProvider compat)
{
// get the distinct set of frameworks, ignoring all special frameworks like Any, and Unsupported
var input = new HashSet<NuGetFramework>(frameworks.Where(f => f.IsSpecificFramework), NuGetFramework.Comparer);
var table = new Dictionary<NuGetFramework, HashSet<NuGetFramework>>(NuGetFramework.Comparer);
foreach (var framework in input)
{
var compatFrameworks = new HashSet<NuGetFramework>(NuGetFramework.Comparer);
table.Add(framework, compatFrameworks);
foreach (var testFramework in input)
{
if (compat.IsCompatible(framework, testFramework))
{
compatFrameworks.Add(testFramework);
}
}
}
return table;
}
internal static bool IsCompatible(
NetPortableProfileTable table,
IFrameworkCompatibilityProvider compatibilityProvider,
IFrameworkNameProvider nameProvider,
FrameworkName projectFrameworkName,
FrameworkName packageTargetFrameworkName)
{
if (projectFrameworkName == null)
{
return(true);
}
var projectNuGetFramework = GetNuGetFramework(
table,
nameProvider,
projectFrameworkName);
var packageTargetNuGetFramework = GetNuGetFramework(
table,
nameProvider,
packageTargetFrameworkName);
var isCompatible = compatibilityProvider.IsCompatible(
projectNuGetFramework,
packageTargetNuGetFramework);
// Fallback to legacy portable compatibility logic if both:
// a) the modern compatibility code returns false
// b) the package framework is portable
if (!isCompatible && packageTargetFrameworkName.IsPortableFramework())
{
return(IsPortableLibraryCompatible(table, projectFrameworkName, packageTargetFrameworkName));
}
return(isCompatible);
}
/// <summary>
/// Nupkg package reader
/// </summary>
/// <param name="stream">Nupkg data stream.</param>
/// <param name="leaveStreamOpen">leave nupkg stream open</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
/// <param name="compatibilityProvider">Framework compatibility provider.</param>
public PackageArchiveReader(Stream stream, bool leaveStreamOpen, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: this(new ZipArchive(stream, ZipArchiveMode.Read, leaveStreamOpen), frameworkProvider, compatibilityProvider)
{
ZipReadStream = stream;
}
public PackageArchiveReader(string filePath, IFrameworkNameProvider frameworkProvider = null, IFrameworkCompatibilityProvider compatibilityProvider = null)
: base(frameworkProvider ?? DefaultFrameworkNameProvider.Instance, compatibilityProvider ?? DefaultCompatibilityProvider.Instance)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
_zipArchive = new ZipArchive(File.OpenRead(filePath), ZipArchiveMode.Read);
}
public FrameworkLogic()
{
_reducer = new FrameworkReducer();
_compatibilityProvider = DefaultCompatibilityProvider.Instance;
}
/// <summary>
/// Nupkg package reader
/// </summary>
/// <param name="zipArchive">ZipArchive containing the nupkg data.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
/// <param name="compatibilityProvider">Framework compatibility provider.</param>
public PackageArchiveReader(ZipArchive zipArchive, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: base(frameworkProvider, compatibilityProvider)
{
if (zipArchive == null)
{
throw new ArgumentNullException(nameof(zipArchive));
}
_zipArchive = zipArchive;
}
public PackageArchiveReader(string filePath, IFrameworkNameProvider frameworkProvider = null, IFrameworkCompatibilityProvider compatibilityProvider = null)
: base(frameworkProvider ?? DefaultFrameworkNameProvider.Instance, compatibilityProvider ?? DefaultCompatibilityProvider.Instance)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
// Since this constructor owns the stream, the responsibility falls here to dispose the stream of an
// invalid .zip archive. If this constructor succeeds, the disposal of the stream is handled by the
// disposal of this instance.
Stream stream = null;
try
{
stream = File.OpenRead(filePath);
_zipArchive = new ZipArchive(stream, ZipArchiveMode.Read);
}
catch
{
stream?.Dispose();
throw;
}
}
/// <summary>
/// Package folder reader
/// </summary>
/// <param name="folder">root directory of an extracted nupkg</param>
/// <param name="frameworkProvider">framework mappings</param>
/// <param name="compatibilityProvider">framework compatibility provider</param>
public PackageFolderReader(DirectoryInfo folder, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: base(frameworkProvider, compatibilityProvider)
{
_root = folder;
}
/// <summary>
/// Nupkg package reader
/// </summary>
/// <param name="stream">Nupkg data stream.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
/// <param name="compatibilityProvider">Framework compatibility provider.</param>
public PackageReader(Stream stream, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: this(stream, false)
{
}
/// <summary>
/// Добавляет в содержимое пакета совместимые версии файлов из указанного пакета.
/// </summary>
/// <param name="packageContent">Содержимое пакета.</param>
/// <param name="packageIdentity">Идентификатор пакета.</param>
/// <param name="targetFramework">Версия совместимого фреймворка.</param>
/// <param name="compatibilityProvider">Провайдер для проверки совместимости фреймворков.</param>
private void FillPackageContent(PackageContent packageContent,
PackageIdentity packageIdentity,
NuGetFramework targetFramework,
IFrameworkCompatibilityProvider compatibilityProvider)
{
var packagePath = GetPackagePath(packageIdentity);
using (var reader = new PackageFolderReader(packagePath))
{
var libItems = GetCompatibleItems(reader, reader.GetLibItems().ToList(), targetFramework, compatibilityProvider);
if (libItems?.Items != null)
{
foreach (var item in libItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PackagingConstants.Folders.Lib, libItems.TargetFramework);
packageContent.Lib.Add(installItem);
}
}
var contentItems = GetCompatibleItems(reader, reader.GetContentItems().ToList(), targetFramework, compatibilityProvider);
if (contentItems?.Items != null)
{
foreach (var item in contentItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PackagingConstants.Folders.Content, contentItems.TargetFramework);
packageContent.Content.Add(installItem);
}
}
var pluginItems = GetCompatibleItems(reader, reader.GetPluginItems().ToList(), targetFramework, compatibilityProvider);
if (pluginItems?.Items != null)
{
foreach (var item in pluginItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PluginFolderName, pluginItems.TargetFramework);
packageContent.Plugin.Add(installItem);
}
}
}
}
private static Dictionary <NuGetFramework, HashSet <NuGetFramework> > GetTable(IEnumerable <NuGetFramework> frameworks, IFrameworkNameProvider mappings, IFrameworkCompatibilityProvider compat)
{
// get the distinct set of frameworks, ignoring all special frameworks like Any, and Unsupported
var input = new HashSet <NuGetFramework>(frameworks.Where(f => f.IsSpecificFramework));
var table = new Dictionary <NuGetFramework, HashSet <NuGetFramework> >();
foreach (var framework in input)
{
var compatFrameworks = new HashSet <NuGetFramework>();
table.Add(framework, compatFrameworks);
foreach (var testFramework in input)
{
if (compat.IsCompatible(framework, testFramework))
{
compatFrameworks.Add(testFramework);
}
}
}
return(table);
}
public CompatibilityListProvider(IFrameworkNameProvider nameProvider, IFrameworkCompatibilityProvider compatibilityProvider)
{
_nameProvider = nameProvider;
_compatibilityProvider = compatibilityProvider;
_reducer = new FrameworkReducer(_nameProvider, _compatibilityProvider);
}
/// <summary>
/// Package folder reader
/// </summary>
/// <param name="folder">root directory of an extracted nupkg</param>
/// <param name="frameworkProvider">framework mappings</param>
/// <param name="compatibilityProvider">framework compatibility provider</param>
public PackageFolderReader(DirectoryInfo folder, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: base(frameworkProvider, compatibilityProvider)
{
_root = folder;
}
/// <summary>
/// Nupkg package reader
/// </summary>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
/// <param name="compatibilityProvider">Framework compatibility provider.</param>
private PackageArchiveReader(IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: base(frameworkProvider, compatibilityProvider)
{
_environmentVariableReader = EnvironmentVariableWrapper.Instance;
}
/// <summary>
/// Возвращает список совместимых элементов.
/// </summary>
/// <param name="reader">Интерфейс для чтения метаданных пакета.</param>
/// <param name="items">Список элементов для выборки.</param>
/// <param name="targetFramework">Версия совместимого фреймворка.</param>
/// <param name="compatibilityProvider">Провайдер для проверки совместимости фреймворков.</param>
private static FrameworkSpecificGroup GetCompatibleItems(PackageReaderBase reader,
IList<FrameworkSpecificGroup> items,
NuGetFramework targetFramework,
IFrameworkCompatibilityProvider compatibilityProvider)
{
// Из пакета выбираются файлы с TargetFramework, который
// является наиболее новым и совместимым с указанным
var compatibleItems = items
.OrderByDescending(i => i.TargetFramework, NuGetFrameworkComparer)
.FirstOrDefault(i => NuGetFrameworkComparer.Compare(i.TargetFramework, targetFramework) <= 0
&& compatibilityProvider.IsCompatible(targetFramework, i.TargetFramework));
if (compatibleItems == null)
{
var portableFramework = reader.GetSupportedFrameworks().FirstOrDefault(i => string.Equals(i.Framework, ".NETPortable", StringComparison.OrdinalIgnoreCase));
if (portableFramework != null && compatibilityProvider.IsCompatible(targetFramework, portableFramework))
{
compatibleItems = items.FirstOrDefault(i => NuGetFrameworkComparer.Compare(i.TargetFramework, portableFramework) == 0);
}
}
return compatibleItems;
}
/// <summary>
/// Nupkg package reader
/// </summary>
/// <param name="zipArchive">ZipArchive containing the nupkg data.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
/// <param name="compatibilityProvider">Framework compatibility provider.</param>
public PackageArchiveReader(ZipArchive zipArchive, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: this(frameworkProvider, compatibilityProvider)
{
_zipArchive = zipArchive ?? throw new ArgumentNullException(nameof(zipArchive));
}
/// <summary>
/// Package folder reader
/// </summary>
/// <param name="folderPath">root directory of an extracted nupkg</param>
/// <param name="frameworkProvider">framework mappings</param>
/// <param name="compatibilityProvider">framework compatibility provider</param>
public PackageFolderReader(string folderPath, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: this(new DirectoryInfo(folderPath), frameworkProvider, compatibilityProvider)
{
}
public PackageArchiveReader(string filePath, IFrameworkNameProvider frameworkProvider = null, IFrameworkCompatibilityProvider compatibilityProvider = null)
: this(frameworkProvider ?? DefaultFrameworkNameProvider.Instance, compatibilityProvider ?? DefaultCompatibilityProvider.Instance)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
// Since this constructor owns the stream, the responsibility falls here to dispose the stream of an
// invalid .zip archive. If this constructor succeeds, the disposal of the stream is handled by the
// disposal of this instance.
Stream stream = null;
try
{
stream = File.OpenRead(filePath);
ZipReadStream = stream;
_zipArchive = new ZipArchive(stream, ZipArchiveMode.Read);
}
catch (Exception ex)
{
stream?.Dispose();
throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.InvalidPackageNupkg, filePath), ex);
}
}
/// <summary>
/// Nupkg package reader
/// </summary>
/// <param name="stream">Nupkg data stream.</param>
/// <param name="leaveStreamOpen">leave nupkg stream open</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
/// <param name="compatibilityProvider">Framework compatibility provider.</param>
public PackageReader(Stream stream, bool leaveStreamOpen, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: this(new ZipArchive(stream, ZipArchiveMode.Read, leaveStreamOpen), frameworkProvider, compatibilityProvider)
{
}
/// <summary>
/// Nupkg package reader
/// </summary>
/// <param name="stream">Nupkg data stream.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
/// <param name="compatibilityProvider">Framework compatibility provider.</param>
public PackageArchiveReader(Stream stream, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: this(stream, false)
{
}
/// <summary>
/// Package folder reader
/// </summary>
/// <param name="folderPath">root directory of an extracted nupkg</param>
/// <param name="frameworkProvider">framework mappings</param>
/// <param name="compatibilityProvider">framework compatibility provider</param>
public PackageFolderReader(string folderPath, IFrameworkNameProvider frameworkProvider, IFrameworkCompatibilityProvider compatibilityProvider)
: this(new DirectoryInfo(folderPath), frameworkProvider, compatibilityProvider)
{
}
