private string DetermineAppDomainTargetFramework(string frameworkName)
{
FrameworkName framework;
Version version = null;
if (!string.IsNullOrEmpty(frameworkName))
{
if (!FrameworkNameUtility.TryParseFrameworkName(frameworkName, out framework))
{
Logger.TraceError($"[{nameof(DomainManager)}] Failed to parse framework name: {frameworkName}");
}
else if (!framework.Identifier.Equals(FrameworkNames.LongNames.Dnx, StringComparison.OrdinalIgnoreCase))
{
Logger.TraceError($"[{nameof(DomainManager)}] Non-DNX framework name: {frameworkName}");
}
else
{
// It's a DNX framework! So just use that version as the .NET version
version = framework.Version;
}
}
// If we didn't get a version from parsing the framework name, use the highest one in project.json
if (version == null)
{
// Calculate it from project.json
version = SelectHighestSupportedDnxVersion(_info.ApplicationBase);
}
// Now that we have a version, build the TFMs and the AppDomain quirking mode TFM
_dnxTfm = new FrameworkName(FrameworkNames.LongNames.Dnx, version);
Logger.TraceInformation($"[{nameof(DomainManager)}] Using Desktop CLR v{version}");
return($"{FrameworkNames.LongNames.NetFramework}, Version=v{version}");
}
protected PackageFileBase(string path)
{
Path = path;
FrameworkNameUtility.ParseFrameworkNameFromFilePath(path, out var effectivePath);
TargetFramework = new FrameworkName(NuGetFramework.Parse(effectivePath).DotNetFrameworkName);
EffectivePath = effectivePath;
}
public StreamPackageFile(Stream stream, string path)
{
_stream = stream;
Path = path;
TargetFramework = FrameworkNameUtility.ParseFrameworkNameFromFilePath(path, out var effectivePath);
EffectivePath = effectivePath;
LastWriteTime = DateTimeOffset.Now;
}
private static IPackageFile CreatePackageFile(string name)
{
var file = new InMemoryFile();
file.Path = name;
file.Stream = new MemoryStream();
string effectivePath;
var fx = FrameworkNameUtility.ParseFrameworkNameFromFilePath(name, out effectivePath);
file.EffectivePath = effectivePath;
file.TargetFramework = fx;
return(file);
}
public static IPackageFile CreatePackageFile(string name)
{
var file = new Mock <IPackageFile>();
file.SetupGet(f => f.Path).Returns(name);
file.Setup(f => f.GetStream()).Returns(new MemoryStream());
string effectivePath;
var fx = FrameworkNameUtility.ParseNuGetFrameworkFromFilePath(name, out effectivePath);
file.SetupGet(f => f.EffectivePath).Returns(effectivePath);
file.SetupGet(f => f.NuGetFramework).Returns(fx);
return(file.Object);
}
protected PackageFileBase(string path)
{
Path = path;
// make sure we switch to the directory char per platform for this check as ParseNuGetFrameworkFromFilePath looks for that
var nuf = FrameworkNameUtility.ParseNuGetFrameworkFromFilePath(path?.Replace('\\', System.IO.Path.DirectorySeparatorChar), out var effectivePath);
EffectivePath = effectivePath;
NuGetFramework = nuf;
if (nuf != null)
{
TargetFramework = new FrameworkName(NuGetFramework.DotNetFrameworkName);
}
}
protected PackageFileBase(string path)
{
Path = path;
FrameworkNameUtility.ParseFrameworkNameFromFilePath(path, out var effectivePath);
EffectivePath = effectivePath;
try
{
TargetFramework = new FrameworkName(NuGetFramework.Parse(effectivePath).DotNetFrameworkName);
}
catch (ArgumentException) // could be an invalid framework/version
{
}
}
private static bool IsValidFrameworkName(string path)
{
FrameworkName fx;
try
{
string effectivePath;
fx = FrameworkNameUtility.ParseFrameworkNameFromFilePath(path, out effectivePath);
}
catch (ArgumentException)
{
fx = null;
}
return(fx != null);
}
internal static bool IsValidFrameworkName(string path)
{
NuGetFramework fx;
try
{
string effectivePath;
fx = FrameworkNameUtility.ParseNuGetFrameworkFromFilePath(path, out effectivePath);
}
catch (ArgumentException)
{
fx = null;
}
// return false if the framework is Null or Unsupported
return(fx != null && fx.Framework != NuGetFramework.UnsupportedFramework.Framework);
}
public static Mock <IPackageFile> CreateMockedPackageFile(string directory, string fileName, string content = null)
{
string path = Path.Combine(directory, fileName);
content = content ?? path;
var mockFile = new Mock <IPackageFile>();
mockFile.Setup(m => m.Path).Returns(path);
mockFile.Setup(m => m.GetStream()).Returns(() => new MemoryStream(Encoding.Default.GetBytes(content)));
string effectivePath;
FrameworkName fn = FrameworkNameUtility.ParseFrameworkNameFromFilePath(path, out effectivePath);
mockFile.Setup(m => m.TargetFramework).Returns(fn);
mockFile.Setup(m => m.EffectivePath).Returns(effectivePath);
mockFile.Setup(m => m.TargetFramework).Returns(fn);
return(mockFile);
}
private static IPackageFile CreatePackageFile(string name)
{
var file = new InMemoryFile
{
Path = name,
Stream = new MemoryStream()
};
string effectivePath;
var fx = FrameworkNameUtility.ParseNuGetFrameworkFromFilePath(name, out effectivePath);
file.EffectivePath = effectivePath;
if (fx != null)
{
file.NuGetFramework = fx;
if (fx.Version.Major < 5)
{
file.TargetFramework = new FrameworkName(fx.DotNetFrameworkName);
}
}
return(file);
}
