public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
var package = FindCandidate(libraryRange.Name, libraryRange.VersionRange);
if (package != null)
{
LockFileFrameworkGroup group = null;
IEnumerable <LibraryDependency> dependencies;
bool resolved = true;
if (package.LockFileLibrary != null)
{
// If we have a lock file, it MUST have an exact match for this target
// framework
group = package.LockFileLibrary.FrameworkGroups.FirstOrDefault(f => f.TargetFramework == targetFramework);
if (group == null)
{
resolved = false;
dependencies = Enumerable.Empty <LibraryDependency>();
}
else
{
dependencies = GetDependencies(package, targetFramework, group);
}
}
else
{
dependencies = GetDependencies(package, targetFramework, lockFileGroup: null);
}
return(new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = package.Id,
Version = package.Version
},
Type = "Package",
Dependencies = dependencies,
Resolved = resolved
});
}
return(null);
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
if (PlatformHelper.IsMono)
{
return(null);
}
if (!VersionUtility.IsDesktop(targetFramework))
{
return(null);
}
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
if (!TryResolvePartialName(name, out path))
{
return(null);
}
SemanticVersion assemblyVersion = VersionUtility.GetAssemblyVersion(path);
if (version == null || version == assemblyVersion)
{
_resolvedPaths[name] = path;
return(new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = name,
Version = assemblyVersion,
IsGacOrFrameworkReference = true
},
LoadableAssemblies = new[] { name },
Dependencies = Enumerable.Empty <LibraryDependency>()
});
}
return(null);
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
return(new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = libraryRange.Name,
IsGacOrFrameworkReference = libraryRange.IsGacOrFrameworkReference,
Version = libraryRange.VersionRange?.MinVersion
},
Dependencies = Enumerable.Empty <LibraryDependency>(),
Resolved = false
});
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
if (!RuntimeEnvironmentHelper.IsWindows)
{
return(null);
}
if (!VersionUtility.IsDesktop(targetFramework))
{
return(null);
}
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
if (!TryResolvePartialName(libraryRange.GetReferenceAssemblyName(), version, out path))
{
return(null);
}
_resolvedPaths[name] = path;
return(new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = name,
Version = version,
IsGacOrFrameworkReference = true
},
LoadableAssemblies = new[] { libraryRange.GetReferenceAssemblyName() },
Dependencies = Enumerable.Empty <LibraryDependency>()
});
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
var name = libraryRange.GetReferenceAssemblyName();
var version = libraryRange.VersionRange?.MinVersion;
string path;
Version assemblyVersion;
if (!FrameworkResolver.TryGetAssembly(name, targetFramework, out path, out assemblyVersion))
{
return(null);
}
if (version == null || version.Version == assemblyVersion)
{
_resolvedPaths[libraryRange.Name] = path;
return(new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = libraryRange.Name,
Version = new SemanticVersion(assemblyVersion),
IsGacOrFrameworkReference = true
},
LoadableAssemblies = new[] { name },
Dependencies = Enumerable.Empty <LibraryDependency>()
});
}
return(null);
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
string name = libraryRange.Name;
Project project;
// Can't find a project file with the name so bail
if (!_projectResolver.TryResolveProject(name, out project))
{
return(null);
}
// This never returns null
var targetFrameworkInfo = project.GetTargetFramework(targetFramework);
var targetFrameworkDependencies = new List <LibraryDependency>(targetFrameworkInfo.Dependencies);
if (VersionUtility.IsDesktop(targetFramework))
{
targetFrameworkDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange("mscorlib", frameworkReference: true)
});
targetFrameworkDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange("System", frameworkReference: true)
});
targetFrameworkDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange("System.Core", frameworkReference: true)
});
targetFrameworkDependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange("Microsoft.CSharp", frameworkReference: true)
});
}
var dependencies = project.Dependencies.Concat(targetFrameworkDependencies).ToList();
var loadableAssemblies = new List <string>();
if (project.IsLoadable)
{
loadableAssemblies.Add(project.Name);
}
// Mark the library as unresolved if there were specified frameworks
// and none of them resolved
bool unresolved = targetFrameworkInfo.FrameworkName == null &&
project.GetTargetFrameworks().Any();
return(new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = project.Name,
Version = project.Version
},
Type = "Project",
Path = project.ProjectFilePath,
Framework = targetFrameworkInfo.FrameworkName,
Dependencies = dependencies,
LoadableAssemblies = loadableAssemblies,
Resolved = !unresolved
});
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
LockFileTargetLibrary targetLibrary = null;
var versionRange = libraryRange.VersionRange;
// REVIEW: This is a little messy because we have the lock file logic and non lock file logic in the same class
// The runtime rewrite separates the 2 things.
if (_lookup != null)
{
// This means we have a lock file and the target should have
var lookupKey = Tuple.Create((string)null, targetFramework, libraryRange.Name);
if (_lookup.TryGetValue(lookupKey, out targetLibrary))
{
// Adjust the target version so we find the right one when looking at the
// lock file libraries
versionRange = new SemanticVersionRange(targetLibrary.Version);
}
}
var package = FindCandidate(libraryRange.Name, versionRange);
if (package != null)
{
IEnumerable <LibraryDependency> dependencies;
var resolved = true;
var compatible = true;
if (package.LockFileLibrary != null)
{
if (targetLibrary?.Version == package.LockFileLibrary.Version)
{
dependencies = GetDependencies(package, targetFramework, targetLibrary);
}
else
{
resolved = false;
dependencies = Enumerable.Empty <LibraryDependency>();
}
// If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with
// current target framework, we should mark this dependency as unresolved
if (targetLibrary != null)
{
var containsAssembly = package.LockFileLibrary.Files
.Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") ||
x.StartsWith($"lib{Path.DirectorySeparatorChar}"));
compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any() ||
!containsAssembly;
resolved = compatible;
}
}
else
{
dependencies = GetDependencies(package, targetFramework, targetLibrary: null);
}
return(new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = package.Id,
Version = package.Version
},
Type = "Package",
Dependencies = dependencies,
Resolved = resolved,
Compatible = compatible
});
}
return(null);
}
