public static string GetContainingModuleName(this TypeReferenceHandle typeRefHandle, MetadataReader reader)
{
var typeRef = typeRefHandle.GetTypeReference(reader);
Handle currentHandle = typeRef.ParentNamespaceOrType;
Debug.Assert(!currentHandle.IsNull(reader));
while (!currentHandle.IsNull(reader))
{
switch (currentHandle.HandleType)
{
case HandleType.TypeReference:
case HandleType.NamespaceReference:
currentHandle = typeRef.ParentNamespaceOrType;
break;
case HandleType.ScopeReference:
return(currentHandle.GetFullName(reader));
default:
return("?");
}
}
return("?");
}
public static void GetFullName(this TypeReferenceHandle typeRefHandle, MetadataReader reader, out string name, out string enclosing, out string nspace)
{
var typeRef = typeRefHandle.GetTypeReference(reader);
Debug.Assert(!typeRef.TypeName.IsNull(reader));
name = typeRef.TypeName.GetConstantStringValue(reader).Value;
enclosing = typeRef.ParentNamespaceOrType.HandleType == HandleType.TypeReference ? typeRef.ParentNamespaceOrType.GetFullName(reader) : null;
nspace = typeRef.ParentNamespaceOrType.HandleType == HandleType.NamespaceReference ? typeRef.ParentNamespaceOrType.GetFullName(reader) : null;
}
private String GetTypeFullNameFromTypeRef(TypeReferenceHandle typeReferenceHandle, MetadataReader reader)
{
String s = "";
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
s = typeReference.TypeName.GetString(reader);
Handle parentHandle = typeReference.ParentNamespaceOrType;
HandleType parentHandleType = parentHandle.HandleType;
if (parentHandleType == HandleType.TypeReference)
{
String containingTypeName = GetTypeFullNameFromTypeRef(parentHandle.ToTypeReferenceHandle(reader), reader);
s = containingTypeName + "+" + s;
}
else if (parentHandleType == HandleType.NamespaceReference)
{
NamespaceReferenceHandle namespaceReferenceHandle = parentHandle.ToNamespaceReferenceHandle(reader);
for (;;)
{
NamespaceReference namespaceReference = namespaceReferenceHandle.GetNamespaceReference(reader);
String namespacePart = namespaceReference.Name.GetStringOrNull(reader);
if (namespacePart == null)
{
break; // Reached the root namespace.
}
s = namespacePart + "." + s;
if (namespaceReference.ParentScopeOrNamespace.HandleType != HandleType.NamespaceReference)
{
break; // Should have reached the root namespace first but this helper is for ToString() - better to
}
// return partial information than crash.
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(reader);
}
}
else
{
// If we got here, the metadata is illegal but this helper is for ToString() - better to
// return something partial than throw.
}
return(s);
}
public static string GetFullName(this TypeReferenceHandle typeRefHandle, MetadataReader reader)
{
var typeRef = typeRefHandle.GetTypeReference(reader);
Debug.Assert(!typeRef.TypeName.IsNull(reader));
var name = typeRef.TypeName.GetConstantStringValue(reader).Value;
var enclosing = typeRef.ParentNamespaceOrType.HandleType == HandleType.TypeReference ? typeRef.ParentNamespaceOrType.GetFullName(reader) : null;
var nspace = typeRef.ParentNamespaceOrType.HandleType == HandleType.NamespaceReference ? typeRef.ParentNamespaceOrType.GetFullName(reader) : null;
if (enclosing != null && name != null)
{
return(enclosing + "+" + name);
}
else if (nspace != null && name != null)
{
return(nspace + "." + name);
}
return(name);
}
private static string GetTypeFullNameFromTypeRef(TypeReferenceHandle typeReferenceHandle, MetadataReader reader, List <int> genericParameterOffsets)
{
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
string s = typeReference.TypeName.GetString(reader);
Handle parentHandle = typeReference.ParentNamespaceOrType;
HandleType parentHandleType = parentHandle.HandleType;
if (parentHandleType == HandleType.TypeReference)
{
string containingTypeName = GetTypeFullNameFromTypeRef(parentHandle.ToTypeReferenceHandle(reader), reader, genericParameterOffsets);
s = containingTypeName + "." + s;
}
else if (parentHandleType == HandleType.NamespaceReference)
{
NamespaceReferenceHandle namespaceReferenceHandle = parentHandle.ToNamespaceReferenceHandle(reader);
for (;;)
{
NamespaceReference namespaceReference = namespaceReferenceHandle.GetNamespaceReference(reader);
string namespacePart = namespaceReference.Name.GetStringOrNull(reader);
if (namespacePart == null)
{
break; // Reached the root namespace.
}
s = namespacePart + "." + s;
if (namespaceReference.ParentScopeOrNamespace.HandleType != HandleType.NamespaceReference)
{
break; // Should have reached the root namespace first but this helper is for ToString() - better to
}
// return partial information than crash.
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(reader);
}
}
else
{
// If we got here, the metadata is illegal but this helper is for ToString() - better to
// return something partial than throw.
}
return(ConvertBackTickNameToNameWithReducerInputFormat(s, genericParameterOffsets));
}
private static String GetTypeFullNameFromTypeRef(TypeReferenceHandle typeReferenceHandle, MetadataReader reader, List<int> genericParameterOffsets)
{
String s = "";
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
s = typeReference.TypeName.GetString(reader);
Handle parentHandle = typeReference.ParentNamespaceOrType;
HandleType parentHandleType = parentHandle.HandleType;
if (parentHandleType == HandleType.TypeReference)
{
String containingTypeName = GetTypeFullNameFromTypeRef(parentHandle.ToTypeReferenceHandle(reader), reader, genericParameterOffsets);
s = containingTypeName + "." + s;
}
else if (parentHandleType == HandleType.NamespaceReference)
{
NamespaceReferenceHandle namespaceReferenceHandle = parentHandle.ToNamespaceReferenceHandle(reader);
for (; ;)
{
NamespaceReference namespaceReference = namespaceReferenceHandle.GetNamespaceReference(reader);
String namespacePart = namespaceReference.Name.GetStringOrNull(reader);
if (namespacePart == null)
break; // Reached the root namespace.
s = namespacePart + "." + s;
if (namespaceReference.ParentScopeOrNamespace.HandleType != HandleType.NamespaceReference)
break; // Should have reached the root namespace first but this helper is for ToString() - better to
// return partial information than crash.
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToNamespaceReferenceHandle(reader);
}
}
else
{
// If we got here, the metadata is illegal but this helper is for ToString() - better to
// return something partial than throw.
}
return ConvertBackTickNameToNameWithReducerInputFormat(s, genericParameterOffsets);
}
private static RuntimeTypeInfo?TryResolveTypeReference(this TypeReferenceHandle typeReferenceHandle, MetadataReader reader, ref Exception?exception)
{
RuntimeTypeHandle resolvedRuntimeTypeHandle;
if (ReflectionCoreExecution.ExecutionEnvironment.TryGetNamedTypeForTypeReference(reader, typeReferenceHandle, out resolvedRuntimeTypeHandle))
{
return(resolvedRuntimeTypeHandle.GetTypeForRuntimeTypeHandle());
}
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
string name = typeReference.TypeName.GetString(reader);
Handle parent = typeReference.ParentNamespaceOrType;
HandleType parentType = parent.HandleType;
TypeInfo? outerTypeInfo = null;
// Check if this is a reference to a nested type.
if (parentType == HandleType.TypeDefinition)
{
outerTypeInfo = parent.ToTypeDefinitionHandle(reader).GetNamedType(reader);
}
else if (parentType == HandleType.TypeReference)
{
RuntimeTypeInfo?outerType = parent.ToTypeReferenceHandle(reader).TryResolveTypeReference(reader, ref exception);
if (outerType == null)
{
return(null);
}
outerTypeInfo = outerType; // Since we got to outerType via a metadata reference, we're assured GetTypeInfo() won't throw a MissingMetadataException.
}
if (outerTypeInfo != null)
{
// It was a nested type. We've already resolved the containing type recursively - just find the nested among its direct children.
TypeInfo?resolvedTypeInfo = outerTypeInfo.GetDeclaredNestedType(name);
if (resolvedTypeInfo == null)
{
exception = ReflectionCoreExecution.ExecutionDomain.CreateMissingMetadataException(outerTypeInfo, name);
return(null);
}
return(resolvedTypeInfo.CastToRuntimeTypeInfo());
}
// If we got here, the typeReference was to a non-nested type.
if (parentType == HandleType.NamespaceReference)
{
NamespaceReferenceHandle namespaceReferenceHandle = parent.ToNamespaceReferenceHandle(reader);
string fullName = namespaceReferenceHandle.ToFullyQualifiedTypeName(name, reader);
Handle parentHandleToSearch = parent;
while (parentHandleToSearch.HandleType != HandleType.ScopeReference)
{
parentHandleToSearch = parentHandleToSearch.ToNamespaceReferenceHandle(reader).GetNamespaceReference(reader).ParentScopeOrNamespace;
}
ScopeReferenceHandle scopeReferenceHandle = parentHandleToSearch.ToScopeReferenceHandle(reader);
RuntimeAssemblyName assemblyName = scopeReferenceHandle.ToRuntimeAssemblyName(reader);
RuntimeAssemblyInfo runtimeAssembly;
exception = RuntimeAssemblyInfo.TryGetRuntimeAssembly(assemblyName, out runtimeAssembly);
if (exception != null)
{
return(null);
}
RuntimeTypeInfo runtimeType = runtimeAssembly.GetTypeCore(fullName, ignoreCase: false);
if (runtimeType == null)
{
exception = Helpers.CreateTypeLoadException(fullName, assemblyName.FullName);
return(null);
}
return(runtimeType);
}
throw new BadImageFormatException(); // Expected TypeReference parent to be typeRef, typeDef or namespaceRef.
}
//
// Main routine to resolve a typeReference.
//
private static RuntimeType TryResolveTypeReference(this ReflectionDomain reflectionDomain, MetadataReader reader, TypeReferenceHandle typeReferenceHandle, ref Exception exception)
{
{
ExecutionDomain executionDomain = reflectionDomain as ExecutionDomain;
if (executionDomain != null)
{
RuntimeTypeHandle resolvedRuntimeTypeHandle;
if (executionDomain.ExecutionEnvironment.TryGetNamedTypeForTypeReference(reader, typeReferenceHandle, out resolvedRuntimeTypeHandle))
return ReflectionCoreNonPortable.GetTypeForRuntimeTypeHandle(resolvedRuntimeTypeHandle);
}
}
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
String name = typeReference.TypeName.GetString(reader);
Handle parent = typeReference.ParentNamespaceOrType;
HandleType parentType = parent.HandleType;
TypeInfo outerTypeInfo = null;
// Check if this is a reference to a nested type.
if (parentType == HandleType.TypeDefinition)
{
outerTypeInfo = RuntimeNamedTypeInfo.GetRuntimeNamedTypeInfo(reader, parent.ToTypeDefinitionHandle(reader));
}
else if (parentType == HandleType.TypeReference)
{
RuntimeType outerType = reflectionDomain.TryResolveTypeReference(reader, parent.ToTypeReferenceHandle(reader), ref exception);
if (outerType == null)
return null;
outerTypeInfo = outerType.GetTypeInfo(); // Since we got to outerType via a metadata reference, we're assured GetTypeInfo() won't throw a MissingMetadataException.
}
if (outerTypeInfo != null)
{
// It was a nested type. We've already resolved the containing type recursively - just find the nested among its direct children.
TypeInfo resolvedTypeInfo = outerTypeInfo.GetDeclaredNestedType(name);
if (resolvedTypeInfo == null)
{
exception = reflectionDomain.CreateMissingMetadataException(outerTypeInfo, name);
return null;
}
return (RuntimeType)(resolvedTypeInfo.AsType());
}
// If we got here, the typeReference was to a non-nested type.
if (parentType == HandleType.NamespaceReference)
{
AssemblyQualifiedTypeName assemblyQualifiedTypeName = parent.ToNamespaceReferenceHandle(reader).ToAssemblyQualifiedTypeName(name, reader);
RuntimeType runtimeType;
exception = assemblyQualifiedTypeName.TryResolve(reflectionDomain, null, /*ignoreCase: */false, out runtimeType);
if (exception != null)
return null;
return runtimeType;
}
throw new BadImageFormatException(); // Expected TypeReference parent to be typeRef, typeDef or namespaceRef.
}
//
// Main routine to resolve a typeReference.
//
private static RuntimeType TryResolveTypeReference(this ReflectionDomain reflectionDomain, MetadataReader reader, TypeReferenceHandle typeReferenceHandle, ref Exception exception)
{
{
ExecutionDomain executionDomain = reflectionDomain as ExecutionDomain;
if (executionDomain != null)
{
RuntimeTypeHandle resolvedRuntimeTypeHandle;
if (executionDomain.ExecutionEnvironment.TryGetNamedTypeForTypeReference(reader, typeReferenceHandle, out resolvedRuntimeTypeHandle))
{
return(ReflectionCoreNonPortable.GetTypeForRuntimeTypeHandle(resolvedRuntimeTypeHandle));
}
}
}
TypeReference typeReference = typeReferenceHandle.GetTypeReference(reader);
String name = typeReference.TypeName.GetString(reader);
Handle parent = typeReference.ParentNamespaceOrType;
HandleType parentType = parent.HandleType;
TypeInfo outerTypeInfo = null;
// Check if this is a reference to a nested type.
if (parentType == HandleType.TypeDefinition)
{
outerTypeInfo = RuntimeNamedTypeInfo.GetRuntimeNamedTypeInfo(reader, parent.ToTypeDefinitionHandle(reader));
}
else if (parentType == HandleType.TypeReference)
{
RuntimeType outerType = reflectionDomain.TryResolveTypeReference(reader, parent.ToTypeReferenceHandle(reader), ref exception);
if (outerType == null)
{
return(null);
}
outerTypeInfo = outerType.GetTypeInfo(); // Since we got to outerType via a metadata reference, we're assured GetTypeInfo() won't throw a MissingMetadataException.
}
if (outerTypeInfo != null)
{
// It was a nested type. We've already resolved the containing type recursively - just find the nested among its direct children.
TypeInfo resolvedTypeInfo = outerTypeInfo.GetDeclaredNestedType(name);
if (resolvedTypeInfo == null)
{
exception = reflectionDomain.CreateMissingMetadataException(outerTypeInfo, name);
return(null);
}
return((RuntimeType)(resolvedTypeInfo.AsType()));
}
// If we got here, the typeReference was to a non-nested type.
if (parentType == HandleType.NamespaceReference)
{
AssemblyQualifiedTypeName assemblyQualifiedTypeName = parent.ToNamespaceReferenceHandle(reader).ToAssemblyQualifiedTypeName(name, reader);
RuntimeType runtimeType;
exception = assemblyQualifiedTypeName.TryResolve(reflectionDomain, null, /*ignoreCase: */ false, out runtimeType);
if (exception != null)
{
return(null);
}
return(runtimeType);
}
throw new BadImageFormatException(); // Expected TypeReference parent to be typeRef, typeDef or namespaceRef.
}
