public static IAssemblyReference GetAssemblyReference(IType value)
{
ITypeReference typeReference = value as ITypeReference;
if (typeReference != null)
{
ITypeReference declaringType = typeReference.Owner as ITypeReference;
if (declaringType != null)
{
return(GetAssemblyReference(declaringType));
}
IModuleReference moduleReference = typeReference.Owner as IModuleReference;
if (moduleReference != null)
{
IModule module = moduleReference.Resolve();
return(module.Assembly);
}
IAssemblyReference assemblyReference = typeReference.Owner as IAssemblyReference;
if (assemblyReference != null)
{
return(assemblyReference);
}
}
throw new NotSupportedException();
}
protected void Init(IModuleReference mainAssembly, IEnumerable <IModuleReference> assemblyReferences)
{
if (mainAssembly == null)
{
throw new ArgumentNullException(nameof(mainAssembly));
}
if (assemblyReferences == null)
{
throw new ArgumentNullException(nameof(assemblyReferences));
}
var context = new SimpleTypeResolveContext(this);
this.mainModule = mainAssembly.Resolve(context);
List <IModule> assemblies = new List <IModule>();
assemblies.Add(this.mainModule);
List <IModule> referencedAssemblies = new List <IModule>();
foreach (var asmRef in assemblyReferences)
{
IModule asm;
try
{
asm = asmRef.Resolve(context);
}
catch (InvalidOperationException)
{
throw new InvalidOperationException("Tried to initialize compilation with an invalid assembly reference. (Forgot to load the assembly reference ? - see CecilLoader)");
}
if (asm != null && !assemblies.Contains(asm))
{
assemblies.Add(asm);
}
if (asm != null && !referencedAssemblies.Contains(asm))
{
referencedAssemblies.Add(asm);
}
}
this.assemblies = assemblies.AsReadOnly();
this.referencedAssemblies = referencedAssemblies.AsReadOnly();
this.knownTypeCache = new KnownTypeCache(this);
this.initialized = true;
}
public IType Resolve(ITypeResolveContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
IType type = null;
if (module == null)
{
// No assembly specified: look in all assemblies, but prefer the current assembly
if (context.CurrentModule != null)
{
type = context.CurrentModule.GetTypeDefinition(fullTypeName);
}
if (type == null)
{
type = ResolveInAllAssemblies(context);
}
}
else
{
// Assembly specified: only look in the specified assembly.
// But if that's not loaded in the compilation, allow fall back to other assemblies.
// (the non-loaded assembly might be a facade containing type forwarders -
// for example, when referencing a portable library from a non-portable project)
IModule asm = module.Resolve(context);
if (asm != null)
{
type = asm.GetTypeDefinition(fullTypeName);
}
else
{
type = ResolveInAllAssemblies(context);
}
}
return(type ?? new UnknownType(fullTypeName, isReferenceType));
}
public static IAssemblyReference GetAssemblyReference(IType value)
{
ITypeReference reference = value as ITypeReference;
if (reference != null)
{
ITypeReference owner = reference.Owner as ITypeReference;
if (owner != null)
{
return(GetAssemblyReference(owner));
}
IModuleReference reference4 = reference.Owner as IModuleReference;
if (reference4 != null)
{
return(reference4.Resolve().Assembly);
}
IAssemblyReference reference3 = reference.Owner as IAssemblyReference;
if (reference3 != null)
{
return(reference3);
}
}
throw new NotSupportedException();
}
private IAssemblyReference GetAssemblyReference(ITypeReference value)
{
if (value.Owner is ITypeReference)
{
return(this.GetAssemblyReference(value.Owner as ITypeReference));
}
else if (value.Owner is IAssemblyReference)
{
return(value.Owner as IAssemblyReference);
}
else if (value.Owner is IModuleReference)
{
IModuleReference moduleReference = (IModuleReference)value.Owner;
IModule module = moduleReference.Resolve();
if (module != null)
{
return(module.Assembly);
}
return(null);
}
throw new NotSupportedException("Unable to get assembly reference for type of code identifier.");
}
private TreeNode FindNode(IMemberReference memberReference)
{
if (memberReference is IAssemblyReference)
{
foreach (TreeNode node in _assembliesTree.Nodes)
{
if (node.Tag == memberReference)
{
return(node);
}
}
return(null);
}
if (memberReference is IResourceReference)
{
IResourceReference resourceReference = (IResourceReference)memberReference;
TreeNode assemblyNode = FindNode(resourceReference.Resolve().Assembly);
TreeNode resourcesNode = null;
foreach (TreeNode childNode in assemblyNode.Nodes)
{
if (childNode.Text == "Resources")
{
resourcesNode = childNode;
}
}
return(FindNode(memberReference, resourcesNode));
}
if (memberReference is IModuleReference)
{
IModuleReference moduleReference = (IModuleReference)memberReference;
return(FindNode(memberReference, FindNode(moduleReference.Resolve().Assembly)));
}
if (memberReference is ITypeReference)
{
ITypeReference typeReference = (ITypeReference)memberReference;
if (typeReference.Resolve().DeclaringType != null)
{
TreeNode declaringTypeNode = FindNode(typeReference.Resolve().DeclaringType);
return(FindNode(memberReference, declaringTypeNode));
}
else
{
TreeNode moduleNode = FindNode(typeReference.Resolve().Module);
foreach (TreeNode namespaceNode in moduleNode.Nodes)
{
if (((namespaceNode.Text == "-") && (typeReference.Namespace == null)) ||
(namespaceNode.Text == typeReference.Namespace))
{
return(FindNode(memberReference, namespaceNode));
}
}
}
return(null);
}
if (memberReference is IMethodReference)
{
IMethodReference methodReference = (IMethodReference)memberReference;
TreeNode typeNode = FindNode(methodReference.Resolve().DeclaringType);
if (typeNode == null)
{
return(null);
}
foreach (TreeNode node in typeNode.Nodes)
{
if (node.Tag == memberReference)
{
return(node);
}
if ((node.Tag is IPropertyReference) || (node.Tag is IEventReference))
{
TreeNode nestedEventNode = FindNode(memberReference, node);
if (nestedEventNode != null)
{
return(nestedEventNode);
}
}
}
return(null);
}
if (memberReference is IFieldReference)
{
IFieldReference fieldReference = (IFieldReference)memberReference;
return(FindNode(memberReference, FindNode(fieldReference.Resolve().DeclaringType)));
}
if (memberReference is IPropertyReference)
{
IPropertyReference propertyReference = (IPropertyReference)memberReference;
return(FindNode(memberReference, FindNode(propertyReference.Resolve().DeclaringType)));
}
if (memberReference is IEventReference)
{
IEventReference eventReference = (IEventReference)memberReference;
return(FindNode(memberReference, FindNode(eventReference.Resolve().DeclaringType)));
}
return(null);
}