internal SystemAssembly AddAssembly(string assemblyfile, AssemblyInfo ainfo, SystemPackage package)
{
if (!File.Exists(assemblyfile))
{
return(null);
}
try {
SystemAssembly asm = SystemAssembly.FromFile(assemblyfile, ainfo);
SystemAssembly prevAsm;
if (assemblyFullNameToAsm.TryGetValue(asm.FullName, out prevAsm))
{
asm.NextSameName = prevAsm.NextSameName;
prevAsm.NextSameName = asm;
}
else
{
assemblyFullNameToAsm [asm.FullName] = asm;
}
assemblyPathToPackage [assemblyfile] = package;
return(asm);
} catch {
return(null);
}
}
SystemPackage RegisterPackage(SystemPackageInfo pinfo, bool isInternal, PackageAssemblyInfo[] assemblyFiles)
{
//don't allow packages to duplicate framework packages
SystemPackage oldPackage;
if (packagesHash.TryGetValue(pinfo.Name, out oldPackage))
{
if (oldPackage.IsFrameworkPackage)
{
return(oldPackage);
}
else if (pinfo.IsFrameworkPackage)
{
ForceUnregisterPackage(oldPackage);
}
}
SystemPackage p = new SystemPackage();
List <SystemAssembly> asms = new List <SystemAssembly> ();
foreach (PackageAssemblyInfo asm in assemblyFiles)
{
asms.Add(AddAssembly(asm.File, new AssemblyInfo(asm), p));
}
p.Initialize(pinfo, asms, isInternal);
packages.Add(p);
packagesHash [pinfo.Name] = p;
NotifyChanged();
return(p);
}
SystemPackage RegisterPackage (SystemPackageInfo pinfo, bool isInternal, PackageAssemblyInfo[] assemblyFiles)
{
//don't allow packages to duplicate framework packages
SystemPackage oldPackage;
if (packagesHash.TryGetValue (pinfo.Name, out oldPackage)) {
if (oldPackage.IsFrameworkPackage)
return oldPackage;
else if (pinfo.IsFrameworkPackage)
ForceUnregisterPackage (oldPackage);
}
SystemPackage p = new SystemPackage ();
List<SystemAssembly> asms = new List<SystemAssembly> ();
foreach (PackageAssemblyInfo asm in assemblyFiles) {
if (pinfo.IsFrameworkPackage || !GetAssembliesFromFullNameInternal (asm.FullName, false).Any (a => a.Package != null && a.Package.IsFrameworkPackage))
asms.Add (AddAssembly (asm.File, new AssemblyInfo (asm), p));
}
p.Initialize (pinfo, asms, isInternal);
packages.Add (p);
packagesHash [pinfo.Name] = p;
NotifyChanged ();
return p;
}
internal protected void UnregisterPackage(SystemPackage p)
{
if (!p.IsInternalPackage)
{
throw new InvalidOperationException("Only internal packages can be unregistered");
}
ForceUnregisterPackage(p);
}
void RegisterPcFile(string file)
{
LibraryPackageInfo pinfo = MonoTargetRuntime.PcFileCache.GetPackageInfo(file);
if (pinfo.IsValidPackage)
{
SystemPackage sp = RegisterPackage(pinfo, true);
packages.Add(sp);
}
}
void ForceUnregisterPackage(SystemPackage p)
{
foreach (SystemAssembly asm in p.Assemblies)
{
RemoveAssembly(asm);
}
packages.Remove(p);
packagesHash.Remove(p.Name);
NotifyChanged();
}
public SystemPackage GetPackageFromPath(string assemblyPath)
{
foreach (TargetRuntime r in runtimes)
{
SystemPackage p = r.AssemblyContext.GetPackageFromPath(assemblyPath);
if (p != null)
{
return(p);
}
}
return(null);
}
public SystemPackage GetPackageFromPath(string path)
{
foreach (IAssemblyContext ctx in sources)
{
SystemPackage sp = ctx.GetPackageFromPath(path);
if (sp != null)
{
return(sp);
}
}
return(null);
}
public SystemPackage GetPackage(string name, string version)
{
foreach (IAssemblyContext ctx in sources)
{
SystemPackage sp = ctx.GetPackage(name, version);
if (sp != null)
{
return(sp);
}
}
return(null);
}
internal void InternalAddPackage(SystemPackage package)
{
SystemPackage oldPackage;
if (package.IsFrameworkPackage && !string.IsNullOrEmpty(package.Name) &&
packagesHash.TryGetValue(package.Name, out oldPackage) && !oldPackage.IsFrameworkPackage)
{
ForceUnregisterPackage(oldPackage);
}
packagesHash [package.Name] = package;
packages.Add(package);
}
void RegisterAssembly(string file)
{
SystemPackageInfo spi = new SystemPackageInfo();
spi.Name = file;
spi.Description = Path.GetDirectoryName(file);
spi.Version = "";
spi.IsGacPackage = false;
spi.TargetFramework = Runtime.SystemAssemblyService.GetTargetFrameworkForAssembly(Runtime.SystemAssemblyService.CurrentRuntime, file);
SystemPackage sp = RegisterPackage(spi, true, file);
packages.Add(sp);
}
void RegisterSystemAssemblies(TargetFramework fx)
{
Dictionary <string, List <SystemAssembly> > assemblies = new Dictionary <string, List <SystemAssembly> > ();
Dictionary <string, SystemPackage> packs = new Dictionary <string, SystemPackage> ();
IEnumerable <string> dirs = GetFrameworkFolders(fx);
foreach (AssemblyInfo assembly in fx.Assemblies)
{
foreach (string dir in dirs)
{
string file = Path.Combine(dir, assembly.Name) + ".dll";
if (File.Exists(file))
{
if (assembly.Version == null && IsRunning)
{
try {
System.Reflection.AssemblyName aname = SystemAssemblyService.GetAssemblyNameObj(file);
assembly.Update(aname);
} catch {
// If something goes wrong when getting the name, just ignore the assembly
}
}
string pkg = assembly.Package ?? string.Empty;
SystemPackage package;
if (!packs.TryGetValue(pkg, out package))
{
packs [pkg] = package = new SystemPackage();
assemblies [pkg] = new List <SystemAssembly> ();
}
List <SystemAssembly> list = assemblies [pkg];
list.Add(assemblyContext.AddAssembly(file, assembly, package));
break;
}
}
}
foreach (string pkg in packs.Keys)
{
SystemPackage package = packs [pkg];
List <SystemAssembly> list = assemblies [pkg];
SystemPackageInfo info = GetFrameworkPackageInfo(fx, pkg);
if (!info.IsCorePackage)
{
corePackages.Add(info.Name);
}
package.Initialize(info, list.ToArray(), false);
assemblyContext.InternalAddPackage(package);
}
}
void RegisterSystemAssemblies(TargetFramework fx)
{
var assemblies = new List <SystemAssembly> ();
var package = new SystemPackage();
foreach (AssemblyInfo assembly in fx.Assemblies)
{
var file = Path.Combine(fx.FrameworkAssembliesDirectory, assembly.Name + ".dll");
assemblies.Add(assemblyContext.AddAssembly(file, assembly, package));
}
SystemPackageInfo info = GetFrameworkPackageInfo(fx, "");
package.Initialize(info, assemblies, false);
if (!info.IsCorePackage)
{
corePackages.Add(info.Name);
}
assemblyContext.InternalAddPackage(package);
}
SystemPackage RegisterPackage(SystemPackageInfo pinfo, bool isInternal, PackageAssemblyInfo[] assemblyFiles)
{
//don't allow packages to duplicate framework package names
//but multiple framework packages (from different versions) may have the same name
SystemPackage oldPackage;
if (packagesHash.TryGetValue(pinfo.Name, out oldPackage))
{
if (pinfo.IsFrameworkPackage)
{
if (!oldPackage.IsFrameworkPackage)
{
ForceUnregisterPackage(oldPackage);
}
}
else if (oldPackage.IsFrameworkPackage)
{
return(oldPackage);
}
}
SystemPackage p = new SystemPackage();
List <SystemAssembly> asms = new List <SystemAssembly> ();
foreach (PackageAssemblyInfo asm in assemblyFiles)
{
if (pinfo.IsFrameworkPackage || !GetAssembliesFromFullNameInternal(asm.FullName, false).Any(a => a.Package != null && a.Package.IsFrameworkPackage))
{
asms.Add(AddAssembly(asm.File, new AssemblyInfo(asm), p));
}
}
p.Initialize(pinfo, asms, isInternal);
packages.Add(p);
packagesHash [pinfo.Name] = p;
NotifyChanged();
return(p);
}
void OnPackagesChanged(object s, ExtensionNodeEventArgs args)
{
PackageExtensionNode node = (PackageExtensionNode)args.ExtensionNode;
SystemPackageInfo pi = node.GetPackageInfo();
if (args.Change == ExtensionChange.Add)
{
var existing = assemblyContext.GetPackageInternal(pi.Name);
if (existing == null || (!existing.IsFrameworkPackage || pi.IsFrameworkPackage))
{
RegisterPackage(pi, node.Assemblies);
}
}
else
{
SystemPackage p = assemblyContext.GetPackage(pi.Name, pi.Version);
if (p.IsInternalPackage)
{
assemblyContext.UnregisterPackage(pi.Name, pi.Version);
}
}
}
/*
void AddRequiredPackages (List<string> result, SystemPackage fromPackage)
{
if (fromPackage == null || string.IsNullOrEmpty (fromPackage.Requires))
return;
foreach (string requiredPackageName in fromPackage.Requires.Split (' ')) {
SystemPackage package = AssemblyContext.GetPackage (requiredPackageName);
if (package == null)
continue;
foreach (SystemAssembly assembly in package.Assemblies) {
if (assembly == null)
continue;
string location = AssemblyContext.GetAssemblyLocation (assembly.FullName, ownerProject != null ? ownerProject.TargetFramework : null);
result.Add (location);
}
AddRequiredPackages (result, package);
}
}*/
void UpdatePackageReference ()
{
if (referenceType == ReferenceType.Package && ownerProject != null) {
notFound = false;
string cref = AssemblyContext.FindInstalledAssembly (reference, package, ownerProject.TargetFramework);
if (cref == null)
cref = reference;
cref = AssemblyContext.GetAssemblyNameForVersion (cref, package, ownerProject.TargetFramework);
notFound = (cref == null);
if (cref != null && cref != reference) {
SystemAssembly asm = AssemblyContext.GetAssemblyFromFullName (cref, package, ownerProject.TargetFramework);
bool isFrameworkAssembly = asm != null && asm.Package.IsFrameworkPackage;
if (loadedReference == null && !isFrameworkAssembly) {
loadedReference = reference;
}
reference = cref;
}
cachedPackage = null;
OnStatusChanged ();
}
}
internal void InternalAddPackage (SystemPackage package)
{
SystemPackage oldPackage;
if (package.IsFrameworkPackage && !string.IsNullOrEmpty (package.Name)
&& packagesHash.TryGetValue (package.Name, out oldPackage) && !oldPackage.IsFrameworkPackage) {
ForceUnregisterPackage (oldPackage);
}
packagesHash [package.Name] = package;
packages.Add (package);
}
internal SystemAssembly AddAssembly (string assemblyfile, AssemblyInfo ainfo, SystemPackage package)
{
if (!File.Exists (assemblyfile))
return null;
try {
SystemAssembly asm = SystemAssembly.FromFile (assemblyfile, ainfo);
SystemAssembly prevAsm;
if (assemblyFullNameToAsm.TryGetValue (asm.FullName, out prevAsm)) {
asm.NextSameName = prevAsm.NextSameName;
prevAsm.NextSameName = asm;
} else
assemblyFullNameToAsm [asm.FullName] = asm;
assemblyPathToPackage [assemblyfile] = package;
return asm;
} catch {
return null;
}
}
void ForceUnregisterPackage (SystemPackage p)
{
foreach (SystemAssembly asm in p.Assemblies)
RemoveAssembly (asm);
packages.Remove (p);
packagesHash.Remove (p.Name);
NotifyChanged ();
}
internal protected void UnregisterPackage (SystemPackage p)
{
if (!p.IsInternalPackage)
throw new InvalidOperationException ("Only internal packages can be unregistered");
ForceUnregisterPackage (p);
}
internal protected void UnregisterPackage(string name, string version)
{
SystemPackage p = GetPackage(name, version);
UnregisterPackage(p);
}
void RegisterSystemAssemblies (TargetFramework fx)
{
Dictionary<string,List<SystemAssembly>> assemblies = new Dictionary<string, List<SystemAssembly>> ();
Dictionary<string,SystemPackage> packs = new Dictionary<string, SystemPackage> ();
IEnumerable<string> dirs = GetFrameworkFolders (fx);
foreach (AssemblyInfo assembly in fx.Assemblies) {
foreach (string dir in dirs) {
string file = Path.Combine (dir, assembly.Name) + ".dll";
if (File.Exists (file)) {
if (assembly.Version == null && IsRunning) {
try {
AssemblyName aname = SystemAssemblyService.GetAssemblyNameObj (file);
assembly.Update (aname);
} catch {
// If something goes wrong when getting the name, just ignore the assembly
}
}
string pkg = assembly.Package ?? string.Empty;
SystemPackage package;
if (!packs.TryGetValue (pkg, out package)) {
packs [pkg] = package = new SystemPackage ();
assemblies [pkg] = new List<SystemAssembly> ();
}
List<SystemAssembly> list = assemblies [pkg];
list.Add (assemblyContext.AddAssembly (file, assembly, package));
break;
}
}
}
foreach (string pkg in packs.Keys) {
SystemPackage package = packs [pkg];
List<SystemAssembly> list = assemblies [pkg];
SystemPackageInfo info = GetFrameworkPackageInfo (fx, pkg);
if (!info.IsCorePackage)
corePackages.Add (info.Name);
package.Initialize (info, list.ToArray (), false);
assemblyContext.InternalAddPackage (package);
}
}
internal void ResetReference ()
{
cachedPackage = null;
if (loadedReference != null) {
reference = loadedReference;
loadedReference = null;
UpdatePackageReference ();
} else
UpdatePackageReference ();
}
SystemPackage RegisterPackage (SystemPackageInfo pinfo, bool isInternal, PackageAssemblyInfo[] assemblyFiles)
{
//don't allow packages to duplicate framework package names
//but multiple framework packages (from different versions) may have the same name
SystemPackage oldPackage;
if (packagesHash.TryGetValue (pinfo.Name, out oldPackage)) {
if (pinfo.IsFrameworkPackage) {
if (!oldPackage.IsFrameworkPackage)
ForceUnregisterPackage (oldPackage);
} else if (oldPackage.IsFrameworkPackage) {
return oldPackage;
}
}
SystemPackage p = new SystemPackage ();
List<SystemAssembly> asms = new List<SystemAssembly> ();
foreach (PackageAssemblyInfo asm in assemblyFiles) {
if (pinfo.IsFrameworkPackage || !GetAssembliesFromFullNameInternal (asm.FullName, false).Any (a => a.Package != null && a.Package.IsFrameworkPackage))
asms.Add (AddAssembly (asm.File, new AssemblyInfo (asm), p));
}
p.Initialize (pinfo, asms, isInternal);
packages = packages.Add (p);
packagesHash = packagesHash.SetItem (pinfo.Name, p);
NotifyChanged ();
return p;
}
