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. }