public ProjectReference(SystemAssembly asm)
{
referenceType = ReferenceType.Package;
reference = asm.FullName;
localCopy = false;
if (asm.Package.IsFrameworkPackage)
{
specificVersion = false;
}
if (!asm.Package.IsGacPackage)
{
package = asm.Package.Name;
}
UpdatePackageReference();
}
// Returns true if either
// - has a valid prefix
// - Or all entries are
// assembly names from packages (eg. System, gtk-sharp) or
// variables like $(FOO) or
// *.dll
bool CheckRefs(List <string> list, out string prefix)
{
prefix = GuessRefPrefix(list);
if (prefix.Length > 0)
{
return(true);
}
DotNetProject dnp = data.OwnerProject as DotNetProject;
if (dnp == null)
{
return(false);
}
// 'core' here simply means any assemblies in the gac
foreach (string file in list)
{
try {
string fullName = dnp.AssemblyContext.GetAssemblyFullName(file, dnp.TargetFramework);
if (fullName != null)
{
SystemAssembly asm = dnp.AssemblyContext.GetAssemblyFromFullName(fullName, null, dnp.TargetFramework);
if (asm != null && asm.Package.IsGacPackage)
{
return(true);
}
}
} catch {
// Ignore
}
if (IsPkgRef(file))
{
return(true);
}
// invalid if any entry isn't one of core/variable/dll/pkgrefs
if (!IsVariable(file) && !IsDll(file))
{
return(false);
}
}
return(false);
}
public void SignalRefChange(ProjectReference refInfo, bool newState)
{
TreeIter iter = new TreeIter();
if (store.GetIterFirst(out iter))
{
do
{
SystemAssembly systemAssembly = store.GetValue(iter, 2) as SystemAssembly;
if ((refInfo.Reference == systemAssembly.FullName) && (refInfo.Package == systemAssembly.Package))
{
store.SetValue(iter, 3, newState);
return;
}
} while (store.IterNext(ref iter));
}
}
bool UpdateCorlibReference()
{
// Creates a reference to the correct version of mscorlib, depending
// on the target runtime version. Returns true if the references
// have changed.
DotNetProject prj = Project as DotNetProject;
if (prj == null)
{
return(false);
}
// if (prj.TargetFramework.Id == lastVersion)
// return false;
// Look for an existing mscorlib reference
string currentRefUri = referenceUris.Find(uri => IsCorlibReference(uri));
// Gets the name and version of the mscorlib assembly required by the project
string requiredRefUri = "Assembly:";
SystemAssembly asm = Runtime.SystemAssemblyService.DefaultAssemblyContext.GetAssemblyForVersion(typeof(object).Assembly.FullName, null, prj.TargetFramework);
requiredRefUri += asm.Location;
// Replace the old reference if the target version has changed
if (currentRefUri != null)
{
if (currentRefUri != requiredRefUri)
{
referenceUris.Remove(currentRefUri);
referenceUris.Add(requiredRefUri);
return(true);
}
}
else
{
referenceUris.Add(requiredRefUri);
return(true);
}
return(false);
}
public virtual string[] GetReferencedFileNames(ConfigurationSelector configuration)
{
string s = GetReferencedFileName(configuration);
/* if (referenceType == ReferenceType.Package) {
* List<string> result = new List<string> ();
* result.Add (s);
* AddRequiredPackages (result, Package);
* return result.ToArray ();
* }*/
if (s != null)
{
return new string[] { s }
}
;
return(new string [0]);
}
/*
* 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;
SystemPackage pkg = Package;
if (pkg != null && pkg.IsFrameworkPackage)
{
int i = Include.IndexOf(',');
if (i != -1)
{
Include = Include.Substring(0, i).Trim();
}
}
OnStatusChanged();
}
}
IAssemblyContext AssemblyContext {
get {
if (ownerProject != null)
{
return(ownerProject.AssemblyContext);
}
else
{
return(Runtime.SystemAssemblyService.DefaultAssemblyContext);
}
}
}
TargetRuntime TargetRuntime {
get {
if (ownerProject != null)
{
return(ownerProject.TargetRuntime);
}
else
{
return(Runtime.SystemAssemblyService.DefaultRuntime);
}
}
}
TargetFramework TargetFramework {
get {
if (ownerProject != null)
{
return(ownerProject.TargetFramework);
}
else
{
return(null);
}
}
}
public static ProjectReference CreateAssemblyReference(SystemAssembly asm)
{
return(new ProjectReference(asm));
}
public ImplicitFrameworkAssemblyReference(SystemAssembly assembly)
{
this.Assembly = assembly;
}
