internal void Initialize (SystemPackageInfo info, IEnumerable<SystemAssembly> assemblies, bool isInternal)
{
this.isInternal = isInternal;
this.name = info.Name ?? string.Empty;
this.version = info.Version ?? string.Empty;
this.description = info.Description ?? string.Empty;
this.targetFramework = info.TargetFramework;
this.gacRoot = info.GacRoot;
this.gacPackage = info.IsGacPackage;
IsFrameworkPackage = info.IsFrameworkPackage;
IsCorePackage = info.IsCorePackage;
IsBaseCorePackage = info.IsBaseCorePackage;
this.Requires = info.Requires;
SystemAssembly last = null;
foreach (SystemAssembly asm in assemblies) {
if (asm == null)
continue;
asm.Package = this;
if (this.assemblies == null)
this.assemblies = asm;
else
last.NextSamePackage = asm;
last = asm;
}
}
public virtual string GetAssemblyLocation(string assemblyName, string package, TargetFramework fx)
{
Initialize();
assemblyName = NormalizeAsmName(assemblyName);
SystemAssembly asm = GetAssemblyFromFullName(assemblyName, package, fx);
if (asm != null)
{
return(asm.Location);
}
return(null);
}
// Given the full name of an assembly, returns the corresponding full assembly name
// in the specified target CLR version, or null if it doesn't exist in that version.
public SystemAssembly GetAssemblyForVersion(string fullName, string packageName, TargetFramework fx)
{
Initialize();
fullName = NormalizeAsmName(fullName);
//get the SystemAssembly for the current fullname, NOT the new target fx
//in order to be able to check whether it's a framework assembly
SystemAssembly asm = GetAssemblyFromFullName(fullName, packageName, null);
if (asm == null)
{
return(null);
}
var fxAsms = asm.AllSameName().Where(a => a.Package.IsFrameworkPackage).ToList();
//if the asm is not a framework asm, we don't upgrade it automatically
if (!fxAsms.Any())
{
// Return null if the package is not compatible with the requested version
if (fx.CanReferenceAssembliesTargetingFramework(asm.Package.TargetFramework))
{
return(asm);
}
else
{
return(null);
}
}
var bestFx = BestFrameworkAssembly(fxAsms, fx);
if (bestFx != null)
{
return(bestFx);
}
// We have to find the assembly with the same name in the target fx
string fname = Path.GetFileName(fxAsms.First().Location);
var possible = packages.Where(p => p.IsFrameworkPackage && fx.IncludesFramework(p.TargetFramework))
.SelectMany(p => p.Assemblies)
.Where(a => Path.GetFileName(a.Location) == fname)
.ToList();
return(BestFrameworkAssembly(possible));
}
IEnumerable <SystemAssembly> FindNewerAssembliesSameName(string fullname)
{
AssemblyName reqName = ParseAssemblyName(fullname);
foreach (KeyValuePair <string, SystemAssembly> pair in assemblyFullNameToAsm)
{
AssemblyName foundName = ParseAssemblyName(pair.Key);
if (reqName.Name == foundName.Name && (reqName.Version == null || reqName.Version.CompareTo(foundName.Version) < 0))
{
SystemAssembly asm = pair.Value;
while (asm != null)
{
yield return(asm);
asm = asm.NextSameName;
}
}
}
}
void RemoveAssembly(SystemAssembly asm)
{
SystemAssembly ca;
if (!assemblyFullNameToAsm.TryGetValue(asm.FullName, out ca))
{
return;
}
assemblyPathToPackage.Remove(asm.Location);
SystemAssembly prev = null;
do
{
if (ca == asm)
{
if (prev != null)
{
prev.NextSameName = ca.NextSameName;
}
else if (ca.NextSameName != null)
{
assemblyFullNameToAsm [asm.FullName] = ca.NextSameName;
}
else
{
assemblyFullNameToAsm.Remove(asm.FullName);
}
break;
}
else
{
prev = ca;
ca = ca.NextSameName;
}
} while (ca != null);
}
public SystemAssembly GetAssemblyFromFullName(string fullname, string package, TargetFramework fx)
{
if (package == null)
{
SystemAssembly found = null;
SystemAssembly gacFound = null;
foreach (SystemAssembly asm in GetAssembliesFromFullNameInternal(fullname))
{
if (asm.Package.IsFrameworkPackage && fx != null)
{
if (fx.IncludesFramework(asm.Package.TargetFramework))
{
return(asm);
}
else
{
continue;
}
}
found = asm;
if (asm.Package.IsGacPackage)
{
gacFound = asm;
}
}
return(gacFound ?? found);
}
foreach (SystemAssembly asm in GetAssembliesFromFullNameInternal(fullname))
{
if (package == asm.Package.Name)
{
return(asm);
}
}
return(null);
}
internal static bool CanBeReferenced (Project project, SystemAssembly systemAssembly)
{
var netProject = project as DotNetProject;
if (netProject == null)
return false;
var result = netProject.TargetRuntime.AssemblyContext.GetAssemblyNameForVersion(systemAssembly.FullName, netProject.TargetFramework);
return !string.IsNullOrEmpty (result);
}
/// <summary>
/// Determines whether the specified reference is a Monobjc one.
/// </summary>
/// <param name = "assembly">The assembly.</param>
/// <returns>
/// <c>true</c> if the specified reference is a Monobjc one; otherwise, <c>false</c>.
/// </returns>
public static bool IsMonobjcReference(SystemAssembly assembly)
{
return assembly.Name.StartsWith ("Monobjc");
}
void RemoveAssembly (SystemAssembly asm)
{
SystemAssembly ca;
if (!assemblyFullNameToAsm.TryGetValue (asm.FullName, out ca))
return;
assemblyPathToPackage.Remove (asm.Location);
SystemAssembly prev = null;
do {
if (ca == asm) {
if (prev != null)
prev.NextSameName = ca.NextSameName;
else if (ca.NextSameName != null)
assemblyFullNameToAsm [asm.FullName] = ca.NextSameName;
else
assemblyFullNameToAsm.Remove (asm.FullName);
break;
} else {
prev = ca;
ca = ca.NextSameName;
}
} while (ca != null);
}
ProjectReference AddNewGacReference (DotNetProject project, SystemAssembly sa)
{
ProjectReference pref = new ProjectReference (sa);
project.References.Add (pref);
newGacRefs [sa.Location] = pref;
return pref;
}
public ProjectReference (SystemAssembly asm)
{
referenceType = ReferenceType.Package;
reference = asm.FullName;
if (asm.Package.IsFrameworkPackage)
specificVersion = false;
if (!asm.Package.IsGacPackage)
package = asm.Package.Name;
UpdatePackageReference ();
}
public ProjectReference (SystemAssembly asm)
{
referenceType = ReferenceType.Gac;
reference = asm.FullName;
if (!asm.Package.IsGacPackage)
package = asm.Package.Name;
UpdateGacReference ();
}
// Returns the installed version of the given assembly name
// (it returns the full name of the installed assembly).
public string FindInstalledAssembly(string fullname, string package, TargetFramework fx)
{
Initialize();
var assemblyName = ParseAssemblyName(fullname);
var version = assemblyName.Version;
var stringVersion = version?.ToString();
fullname = assemblyName.Name;
SystemAssembly fasm = GetAssemblyFromFullName(fullname, package, fx);
if (fasm != null)
{
return(fullname);
}
// Try to find a newer version of the same assembly, preferring framework assemblies
if (fx == null)
{
string best = null;
foreach (SystemAssembly asm in FindNewerAssembliesSameName(fullname))
{
if (package == null || asm.Package.Name == package)
{
if (asm.Package.IsFrameworkPackage)
{
return(asm.FullName);
}
else
{
best = asm.FullName;
}
}
}
return(best);
}
var asms = FindNewerAssembliesSameName(fullname).ToList();
if (fx != null)
{
var fxAsm = BestFrameworkAssembly(asms, fx, version);
if (fxAsm != null)
{
return(fxAsm.FullName);
}
}
string bestMatch = null;
foreach (SystemAssembly asm in asms)
{
if (fx.CanReferenceAssembliesTargetingFramework(asm.Package.TargetFramework) &&
(stringVersion == null || stringVersion == asm.Version))
{
if (package != null && asm.Package.Name == package)
{
return(asm.FullName);
}
bestMatch = asm.FullName;
}
}
return(bestMatch);
}
public static ProjectReference CreateAssemblyReference (SystemAssembly asm)
{
return new ProjectReference (asm);
}
ProjectReference (SystemAssembly asm)
{
Init (ReferenceType.Package, asm.FullName, null);
if (asm.Package.IsFrameworkPackage)
specificVersion = false;
if (!asm.Package.IsGacPackage)
package = asm.Package.Name;
UpdatePackageReference ();
}
public ImplicitFrameworkAssemblyReference (SystemAssembly assembly)
{
this.Assembly = assembly;
}
ProjectReference AddNewPackageReference (DotNetProject project, SystemAssembly sa)
{
ProjectReference pref = ProjectReference.CreateAssemblyReference (sa);
project.References.Add (pref);
newPackageRefs [sa.Location] = pref;
return pref;
}
