/*
- Copyright (C) 2009 Jeroen Frijters
+ Copyright (C) 2009-2012 Jeroen Frijters
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
namespace IKVM.Reflection
{
+ public delegate Module ModuleResolveEventHandler(object sender, ResolveEventArgs e);
+
public abstract class Assembly : ICustomAttributeProvider
{
internal readonly Universe universe;
+ protected string fullName; // AssemblyBuilder needs access to this field to clear it when the name changes
+ protected List<ModuleResolveEventHandler> resolvers;
internal Assembly(Universe universe)
{
this.universe = universe;
}
+ public sealed override string ToString()
+ {
+ return FullName;
+ }
+
+ public event ModuleResolveEventHandler ModuleResolve
+ {
+ add
+ {
+ if (resolvers == null)
+ {
+ resolvers = new List<ModuleResolveEventHandler>();
+ }
+ resolvers.Add(value);
+ }
+ remove
+ {
+ resolvers.Remove(value);
+ }
+ }
+
public abstract Type[] GetTypes();
- public abstract string FullName { get; }
public abstract AssemblyName GetName();
public abstract string ImageRuntimeVersion { get; }
public abstract Module ManifestModule { get; }
public abstract Module GetModule(string name);
public abstract string[] GetManifestResourceNames();
public abstract ManifestResourceInfo GetManifestResourceInfo(string resourceName);
- public abstract System.IO.Stream GetManifestResourceStream(string resourceName);
-
- internal Type GetTypeImpl(string typeName)
- {
- Type type = FindType(TypeName.Split(TypeNameParser.Unescape(typeName)));
- if (type == null && __IsMissing)
- {
- throw new MissingAssemblyException((MissingAssembly)this);
- }
- return type;
- }
+ public abstract System.IO.Stream GetManifestResourceStream(string name);
internal abstract Type FindType(TypeName name);
+ internal abstract Type FindTypeIgnoreCase(TypeName lowerCaseName);
// The differences between ResolveType and FindType are:
// - ResolveType is only used when a type is assumed to exist (because another module's metadata claims it)
return FindType(typeName) ?? universe.GetMissingTypeOrThrow(this.ManifestModule, null, typeName);
}
+ public string FullName
+ {
+ get { return fullName ?? (fullName = GetName().FullName); }
+ }
+
public Module[] GetModules()
{
return GetModules(true);
}
+ public IEnumerable<Module> Modules
+ {
+ get { return GetLoadedModules(); }
+ }
+
public Module[] GetLoadedModules()
{
return GetLoadedModules(true);
return list.ToArray();
}
- public Type GetType(string typeName)
+ public IEnumerable<Type> ExportedTypes
{
- return GetType(typeName, false);
+ get { return GetExportedTypes(); }
}
- public Type GetType(string typeName, bool throwOnError)
+ public IEnumerable<TypeInfo> DefinedTypes
{
- TypeNameParser parser = TypeNameParser.Parse(typeName, throwOnError);
+ get
+ {
+ Type[] types = GetTypes();
+ TypeInfo[] typeInfos = new TypeInfo[types.Length];
+ for (int i = 0; i < types.Length; i++)
+ {
+ typeInfos[i] = types[i].GetTypeInfo();
+ }
+ return typeInfos;
+ }
+ }
+
+ public Type GetType(string name)
+ {
+ return GetType(name, false);
+ }
+
+ public Type GetType(string name, bool throwOnError)
+ {
+ return GetType(name, throwOnError, false);
+ }
+
+ public Type GetType(string name, bool throwOnError, bool ignoreCase)
+ {
+ TypeNameParser parser = TypeNameParser.Parse(name, throwOnError);
if (parser.Error)
{
return null;
return null;
}
}
- return parser.Expand(GetTypeImpl(parser.FirstNamePart), this, throwOnError, typeName, false);
+ TypeName typeName = TypeName.Split(TypeNameParser.Unescape(parser.FirstNamePart));
+ Type type = ignoreCase
+ ? FindTypeIgnoreCase(typeName.ToLowerInvariant())
+ : FindType(typeName);
+ if (type == null && __IsMissing)
+ {
+ throw new MissingAssemblyException((MissingAssembly)this);
+ }
+ return parser.Expand(type, this, throwOnError, name, false, ignoreCase);
}
public virtual Module LoadModule(string moduleName, byte[] rawModule)
return CustomAttributeData.__GetCustomAttributes(this, attributeType, inherit);
}
+ public IList<CustomAttributeData> GetCustomAttributesData()
+ {
+ return CustomAttributeData.GetCustomAttributes(this);
+ }
+
+ public IEnumerable<CustomAttributeData> CustomAttributes
+ {
+ get { return GetCustomAttributesData(); }
+ }
+
public static string CreateQualifiedName(string assemblyName, string typeName)
{
- return assemblyName == null ? typeName : typeName + ", " + assemblyName;
+ return typeName + ", " + assemblyName;
}
public static Assembly GetAssembly(Type type)
}
}
+ public virtual bool IsDynamic
+ {
+ get { return false; }
+ }
+
public virtual bool __IsMissing
{
get { return false; }
}
- public virtual AssemblyNameFlags __AssemblyFlags
+ public AssemblyNameFlags __AssemblyFlags
+ {
+ get { return GetAssemblyFlags(); }
+ }
+
+ protected virtual AssemblyNameFlags GetAssemblyFlags()
{
- get { return GetName().Flags; }
+ return GetName().Flags;
}
internal abstract IList<CustomAttributeData> GetCustomAttributesData(Type attributeType);