/// <summary>
/// Creates a NuGetFramework from a folder name using the given mappings.
/// </summary>
public static NuGetFramework Parse(string folderName, IFrameworkNameProvider mappings)
{
if (folderName == null)
{
throw new ArgumentNullException(nameof(folderName));
}
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings));
}
var framework = UnsupportedFramework;
if (folderName.IndexOf(',') > -1)
{
framework = ParseFrameworkName(folderName, mappings);
}
else
{
framework = ParseFolder(folderName, mappings);
}
return framework;
}
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();
}
public PackagesConfigWriter(IFrameworkNameProvider frameworkMappings, Stream stream)
{
_stream = stream;
_closed = false;
_entries = new List <PackageReference>();
_frameworkMappings = frameworkMappings;
}
/// <summary>
/// Creates a NuGetFramework from a folder name using the given mappings.
/// </summary>
public static NuGetFramework Parse(string folderName, IFrameworkNameProvider mappings)
{
if (folderName == null)
{
throw new ArgumentNullException(nameof(folderName));
}
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings));
}
var framework = UnsupportedFramework;
if (folderName.IndexOf(',') > -1)
{
framework = ParseFrameworkName(folderName, mappings);
}
else
{
framework = ParseFolder(folderName, mappings);
}
return(framework);
}
/// <summary>
/// Create a packages.config writer using file path
/// </summary>
/// <param name="fullPath">The full path to write the XML packages.config file into, or load existing packages.config from</param>
/// <param name="createNew">Whether to create a new packages.config file, or load an existing one</param>
/// <param name="frameworkMappings">Framework mappings</param>
public PackagesConfigWriter(string fullPath, bool createNew, IFrameworkNameProvider frameworkMappings)
{
if (fullPath == null)
{
throw new ArgumentNullException(nameof(fullPath));
}
_frameworkMappings = frameworkMappings;
_filePath = fullPath;
if (createNew)
{
CreateDefaultXDocument();
}
// Load the existing packages.config file.
else
{
try
{
using (var stream = new FileStream(fullPath, FileMode.Open, FileAccess.Read))
{
_xDocument = XDocument.Load(stream);
}
}
catch (Exception ex)
{
throw new PackagesConfigWriterException(string.Format(CultureInfo.CurrentCulture,
Strings.FailToLoadPackagesConfig), ex);
}
}
}
/// <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("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(item => item.TargetFramework));
if (mostCompatibleFramework != null)
{
return(items.FirstOrDefault(item => NuGetFramework.Comparer.Equals(item.TargetFramework, mostCompatibleFramework)));
}
}
return(default(T));
}
/// <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(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(selector));
if (mostCompatibleFramework != null)
{
return(items.FirstOrDefault(item => NuGetFramework.Comparer.Equals(selector(item), mostCompatibleFramework)));
}
}
return(null);
}
/// <summary>
/// Creates a NuGetFramework from a folder name using the given mappings.
/// </summary>
public static NuGetFramework Parse(string folderName, IFrameworkNameProvider mappings)
{
if (folderName == null)
{
throw new ArgumentNullException("folderName");
}
if (mappings == null)
{
throw new ArgumentNullException("mappings");
}
Debug.Assert(folderName.IndexOf(";") < 0, "invalid folder name, this appears to contain multiple frameworks");
var framework = UnsupportedFramework;
if (folderName.IndexOf(',') > -1)
{
framework = ParseFrameworkName(folderName, mappings);
}
else
{
framework = ParseFolder(folderName, mappings);
}
return(framework);
}
/// <summary>The TargetFrameworkMoniker identifier of the current NuGetFrameowrk.</summary>
/// <remarks>Formatted to a System.Versioning.FrameworkName</remarks>
public string GetDotNetFrameworkName(IFrameworkNameProvider mappings)
{
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings));
}
// Check for rewrites
var framework = mappings.GetFullNameReplacement(this);
if (framework.IsSpecificFramework)
{
var parts = new List <string>(3)
{
Framework
};
parts.Add(string.Format(CultureInfo.InvariantCulture, "Version=v{0}", GetDisplayVersion(framework.Version)));
if (!string.IsNullOrEmpty(framework.Profile))
{
parts.Add(string.Format(CultureInfo.InvariantCulture, "Profile={0}", framework.Profile));
}
return(string.Join(",", parts));
}
else
{
return(string.Format(CultureInfo.InvariantCulture, "{0},Version=v0.0", framework.Framework));
}
}
/// <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();
}
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);
ZipReadStream = stream;
_zipArchive = new ZipArchive(stream, ZipArchiveMode.Read);
}
catch
{
stream?.Dispose();
throw;
}
}
public PackagesConfigWriter(IFrameworkNameProvider frameworkMappings, Stream stream)
{
_stream = stream;
_closed = false;
_entries = new List<PackageReference>();
_frameworkMappings = frameworkMappings;
}
/// <summary>
/// Formatted to a System.Versioning.FrameworkName
/// </summary>
public string GetDotNetFrameworkName(IFrameworkNameProvider mappings)
{
// Check for rewrites
var framework = mappings.GetFullNameReplacement(this);
var result = string.Empty;
if (framework.IsSpecificFramework)
{
var parts = new List <string>(3)
{
framework.Framework
};
parts.Add(String.Format(CultureInfo.InvariantCulture, "Version=v{0}", GetDisplayVersion(framework.Version)));
if (!String.IsNullOrEmpty(framework.Profile))
{
parts.Add(String.Format(CultureInfo.InvariantCulture, "Profile={0}", framework.Profile));
}
result = String.Join(",", parts);
}
else
{
result = String.Format(CultureInfo.InvariantCulture, "{0},Version=v0.0", framework.Framework);
}
return(result);
}
public CompatibilityTable(IEnumerable <NuGetFramework> frameworks, IFrameworkNameProvider mappings, IFrameworkCompatibilityProvider compat)
{
_compat = compat;
_mappings = mappings;
_table = GetTable(frameworks, _compat);
_reducer = new FrameworkReducer(_mappings, _compat);
}
public DefaultNuGetFramework(IFrameworkNameProvider frameworkNameProvider)
{
Argument.IsNotNull(() => frameworkNameProvider);
_frameworkNameProvider = frameworkNameProvider;
LoadAvailableFrameworks();
}
public PackageDependencyResolverService(IFrameworkNameProvider frameworkNameProvider, ISourceRepositoryProvider sourceRepositoryProvider)
{
Argument.IsNotNull(() => frameworkNameProvider);
Argument.IsNotNull(() => sourceRepositoryProvider);
_frameworkNameProvider = frameworkNameProvider;
repositories = sourceRepositoryProvider.GetRepositories();
}
public ExampleProject(IFrameworkNameProvider frameworkNameProvider)
{
_pathResolver = TypeFactory.Default.CreateInstanceWithParametersAndAutoCompletion <ExamplePackagePathResolver>();
var targetFramework = FrameworkParser.TryParseFrameworkName(Framework, frameworkNameProvider);
SupportedPlatforms = ImmutableList.Create(FrameworkParser.ToSpecificPlatform(targetFramework));
}
/// <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;
}
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);
}
/// <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 static NuGetFramework TryParseFrameworkName(string frameworkString, IFrameworkNameProvider frameworkNameProvider)
{
try
{
return(NuGetFramework.ParseFrameworkName(frameworkString, frameworkNameProvider));
}
catch (ArgumentException)
{
return(NuGetFramework.UnsupportedFramework);
}
}
internal static NuGetFramework GetNuGetFramework(
NetPortableProfileTable table,
IFrameworkNameProvider provider,
FrameworkName framework)
{
// Use the short folder name as the common format between FrameworkName and
// NuGetFramework. With portable frameworks, there are differences in
// FrameworkName and NuGetFramework.DotNetFrameworkName.
var folderName = GetShortFrameworkName(table, framework);
return(NuGetFramework.ParseFolder(folderName, provider));
}
/// <summary>
/// Packages.config reader
/// </summary>
/// <param name="frameworkMappings">Additional target framework mappings for parsing target frameworks</param>
/// <param name="xml">Packages.config XML</param>
public PackagesConfigReader(IFrameworkNameProvider frameworkMappings, XDocument xml)
{
if (xml == null)
{
throw new ArgumentNullException(nameof(xml));
}
if (frameworkMappings == null)
{
throw new ArgumentNullException(nameof(frameworkMappings));
}
_doc = xml;
_frameworkMappings = frameworkMappings;
}
/// <summary>
/// Packages.config reader
/// </summary>
/// <param name="frameworkMappings">Additional target framework mappings for parsing target frameworks</param>
/// <param name="xml">Packages.config XML</param>
public PackagesConfigReader(IFrameworkNameProvider frameworkMappings, XDocument xml)
{
if (xml == null)
{
throw new ArgumentNullException(nameof(xml));
}
if (frameworkMappings == null)
{
throw new ArgumentNullException(nameof(frameworkMappings));
}
_doc = xml;
_frameworkMappings = frameworkMappings;
}
/// <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>
/// Packages.config reader
/// </summary>
/// <param name="stream">Stream containing packages.config</param>
/// <param name="leaveStreamOpen">True will leave the stream open</param>
/// <param name="frameworkMappings">Additional target framework mappings for parsing target frameworks</param>
public PackagesConfigReader(IFrameworkNameProvider frameworkMappings, Stream stream, bool leaveStreamOpen)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
_frameworkMappings = frameworkMappings;
_doc = XDocument.Load(stream);
if (!leaveStreamOpen)
{
stream.Dispose();
}
}
private static void ParseFrameworkNameParts(IFrameworkNameProvider mappings, string[] parts, out string framework, out Version version, out string profile)
{
framework = null;
if (!mappings.TryGetIdentifier(parts[0], out framework))
{
framework = parts[0];
}
version = new Version(0, 0);
profile = null;
var versionPart = SingleOrDefaultSafe(parts.Where(s => s.IndexOf("Version=", StringComparison.OrdinalIgnoreCase) == 0));
var profilePart = SingleOrDefaultSafe(parts.Where(s => s.IndexOf("Profile=", StringComparison.OrdinalIgnoreCase) == 0));
if (!string.IsNullOrEmpty(versionPart))
{
var versionString = versionPart.Split('=')[1].TrimStart('v');
if (versionString.IndexOf('.') < 0)
{
versionString += ".0";
}
if (!Version.TryParse(versionString, out version))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidFrameworkVersion,
versionString));
}
}
if (!string.IsNullOrEmpty(profilePart))
{
profile = profilePart.Split('=')[1];
}
if (StringComparer.OrdinalIgnoreCase.Equals(FrameworkConstants.FrameworkIdentifiers.Portable, framework) &&
!string.IsNullOrEmpty(profile) &&
profile.Contains("-"))
{
// Frameworks within the portable profile are not allowed
// to have profiles themselves #1869
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidPortableFrameworksDueToHyphen,
profile));
}
}
/// <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>
/// Creates a NuGetFramework from a .NET FrameworkName
/// </summary>
public static NuGetFramework ParseFrameworkName(string frameworkName, IFrameworkNameProvider mappings)
{
if (frameworkName == null)
{
throw new ArgumentNullException(nameof(frameworkName));
}
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings));
}
var parts = frameworkName.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray();
NuGetFramework result = null;
// if the first part is a special framework, ignore the rest
if (!TryParseSpecialFramework(parts[0], out result))
{
string platform = null;
if (!mappings.TryGetIdentifier(parts[0], out platform))
{
platform = parts[0];
}
var version = new Version(0, 0);
string profile = null;
var versionPart = SingleOrDefaultSafe(parts.Where(s => s.IndexOf("Version=", StringComparison.OrdinalIgnoreCase) == 0));
var profilePart = SingleOrDefaultSafe(parts.Where(s => s.IndexOf("Profile=", StringComparison.OrdinalIgnoreCase) == 0));
if (!String.IsNullOrEmpty(versionPart))
{
Version.TryParse(versionPart.Split('=')[1].TrimStart('v'), out version);
}
if (!String.IsNullOrEmpty(profilePart))
{
profile = profilePart.Split('=')[1];
}
result = new NuGetFramework(platform, version, profile);
}
return result;
}
/// <summary>
/// Creates a NuGetFramework from a .NET FrameworkName
/// </summary>
public static NuGetFramework ParseFrameworkName(string frameworkName, IFrameworkNameProvider mappings)
{
if (frameworkName == null)
{
throw new ArgumentNullException(nameof(frameworkName));
}
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings));
}
var parts = frameworkName.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray();
NuGetFramework result = null;
// if the first part is a special framework, ignore the rest
if (!TryParseSpecialFramework(parts[0], out result))
{
string platform = null;
if (!mappings.TryGetIdentifier(parts[0], out platform))
{
platform = parts[0];
}
var version = new Version(0, 0);
string profile = null;
var versionPart = SingleOrDefaultSafe(parts.Where(s => s.IndexOf("Version=", StringComparison.OrdinalIgnoreCase) == 0));
var profilePart = SingleOrDefaultSafe(parts.Where(s => s.IndexOf("Profile=", StringComparison.OrdinalIgnoreCase) == 0));
if (!String.IsNullOrEmpty(versionPart))
{
Version.TryParse(versionPart.Split('=')[1].TrimStart('v'), out version);
}
if (!String.IsNullOrEmpty(profilePart))
{
profile = profilePart.Split('=')[1];
}
result = new NuGetFramework(platform, version, profile);
}
return(result);
}
/// <summary>
/// Packages.config reader
/// </summary>
/// <param name="stream">Stream containing packages.config</param>
/// <param name="leaveStreamOpen">True will leave the stream open</param>
/// <param name="frameworkMappings">Additional target framework mappings for parsing target frameworks</param>
public PackagesConfigReader(IFrameworkNameProvider frameworkMappings, Stream stream, bool leaveStreamOpen)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (frameworkMappings == null)
{
throw new ArgumentNullException(nameof(frameworkMappings));
}
_frameworkMappings = frameworkMappings;
_doc = XDocument.Load(stream);
if (!leaveStreamOpen)
{
stream.Dispose();
}
}
/// <summary>
/// Create a packages.config writer using stream
/// </summary>
/// <param name="stream">Stream to write the XML packages.config file into, or load existing packages.config from</param>
/// <param name="createNew">Whether to create a new packages.config file, or load an existing one</param>
/// <param name="frameworkMappings">Framework mappings</param>
public PackagesConfigWriter(Stream stream, bool createNew, IFrameworkNameProvider frameworkMappings)
{
if (stream == null)
{
throw new ArgumentException(nameof(stream));
}
_stream = stream;
_frameworkMappings = frameworkMappings;
if (createNew)
{
CreateDefaultXDocument();
}
// Load the existing packages.config file.
else
{
_xDocument = XDocument.Load(stream);
}
}
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>
/// Creates a NuGetFramework from a .NET FrameworkName
/// </summary>
public static NuGetFramework ParseFrameworkName(string frameworkName, IFrameworkNameProvider mappings)
{
if (frameworkName == null)
{
throw new ArgumentNullException(nameof(frameworkName));
}
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings));
}
var parts = frameworkName.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray();
NuGetFramework result = null;
// if the first part is a special framework, ignore the rest
if (!TryParseSpecialFramework(parts[0], out result))
{
string framework, profile;
Version version;
ParseFrameworkNameParts(mappings, parts, out framework, out version, out profile);
if (version.Major >= 5 &&
StringComparer.OrdinalIgnoreCase.Equals(FrameworkConstants.FrameworkIdentifiers.NetCoreApp, framework))
{
result = new NuGetFramework(framework, version, string.Empty, FrameworkConstants.EmptyVersion);
}
else
{
result = new NuGetFramework(framework, version, profile);
}
}
return(result);
}
/// <summary>
/// Nuspec file reader
/// </summary>
/// <param name="stream">Nuspec file stream.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
public NuspecReader(Stream stream, IFrameworkNameProvider frameworkProvider, bool leaveStreamOpen)
: base(stream, leaveStreamOpen)
{
_frameworkProvider = frameworkProvider;
}
/// <summary>
/// Nuspec file reader.
/// </summary>
public NuspecReader(string path, IFrameworkNameProvider frameworkProvider)
: base(path)
{
_frameworkProvider = frameworkProvider;
}
/// <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>
/// Core package reader
/// </summary>
/// <param name="frameworkProvider">framework mapping provider</param>
public PackageReaderBase(IFrameworkNameProvider frameworkProvider)
: this(frameworkProvider, new CompatibilityProvider(frameworkProvider))
{
}
/// <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>
/// 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)
{
}
public FrameworkExpander(IFrameworkNameProvider mappings)
{
_mappings = mappings;
}
/// <summary>
/// Creates a NuGetFramework from a folder name using the given mappings.
/// </summary>
public static NuGetFramework ParseFolder(string folderName, IFrameworkNameProvider mappings)
{
if (folderName == null)
{
throw new ArgumentNullException(nameof(folderName));
}
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings));
}
if (folderName.IndexOf('%') > -1)
{
folderName = Uri.UnescapeDataString(folderName);
}
NuGetFramework result = null;
// first check if we have a special or common framework
if (!TryParseSpecialFramework(folderName, out result)
&& !TryParseCommonFramework(folderName, out result))
{
// assume this is unsupported unless we find a match
result = UnsupportedFramework;
var parts = RawParse(folderName);
if (parts != null)
{
string framework = null;
if (mappings.TryGetIdentifier(parts.Item1, out framework))
{
var version = FrameworkConstants.EmptyVersion;
if (parts.Item2 == null
|| mappings.TryGetVersion(parts.Item2, out version))
{
var profileShort = parts.Item3;
string profile = null;
if (!mappings.TryGetProfile(framework, profileShort, out profile))
{
profile = profileShort ?? string.Empty;
}
if (StringComparer.OrdinalIgnoreCase.Equals(FrameworkConstants.FrameworkIdentifiers.Portable, framework))
{
IEnumerable<NuGetFramework> clientFrameworks = null;
mappings.TryGetPortableFrameworks(profileShort, out clientFrameworks);
var profileNumber = -1;
if (mappings.TryGetPortableProfile(clientFrameworks, out profileNumber))
{
var portableProfileNumber = FrameworkNameHelpers.GetPortableProfileNumberString(profileNumber);
result = new NuGetFramework(framework, version, portableProfileNumber);
}
else
{
// TODO: should this be unsupported?
result = new NuGetFramework(framework, version, profileShort);
}
}
else
{
result = new NuGetFramework(framework, version, profile);
}
}
}
}
else
{
// If the framework was not recognized check if it is a deprecated framework
NuGetFramework deprecated = null;
if (TryParseDeprecatedFramework(folderName, out deprecated))
{
result = deprecated;
}
}
}
return result;
}
public CompatibilityProvider(IFrameworkNameProvider mappings)
{
_mappings = mappings;
_expander = new FrameworkExpander(mappings);
_cache = new ConcurrentDictionary<int, bool>();
}
/// <summary>
/// Nuspec file reader
/// </summary>
/// <param name="xml">Nuspec file xml data.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
public NuspecReader(XDocument xml, IFrameworkNameProvider frameworkProvider)
: base(xml)
{
_frameworkProvider = frameworkProvider;
}
/// <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)
{
}
/// <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>
/// Nuspec file reader
/// </summary>
/// <param name="stream">Nuspec file stream.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
public NuspecReader(Stream stream, IFrameworkNameProvider frameworkProvider)
: base(stream)
{
_frameworkProvider = frameworkProvider;
}
/// <summary>
/// Nuspec file reader
/// </summary>
/// <param name="xml">Nuspec file xml data.</param>
/// <param name="frameworkProvider">Framework mapping provider for NuGetFramework parsing.</param>
public NuspecReader(XDocument xml, IFrameworkNameProvider frameworkProvider)
: base(xml)
{
_frameworkProvider = frameworkProvider;
}