private Exception UncachedTryResolveCaseSensitive(ReflectionDomain reflectionDomain, RuntimeAssembly currentAssembly, out RuntimeType result) { result = null; foreach (QScopeDefinition scopeDefinition in currentAssembly.AllScopes) { MetadataReader reader = scopeDefinition.Reader; ScopeDefinitionHandle scopeDefinitionHandle = scopeDefinition.Handle; NamespaceDefinition namespaceDefinition; if (!TryResolveNamespaceDefinitionCaseSensitive(reader, scopeDefinitionHandle, out namespaceDefinition)) { continue; } // We've successfully drilled down the namespace chain. Now look for a top-level type matching the type name. IEnumerable <TypeDefinitionHandle> candidateTypes = namespaceDefinition.TypeDefinitions; foreach (TypeDefinitionHandle candidateType in candidateTypes) { TypeDefinition typeDefinition = candidateType.GetTypeDefinition(reader); if (typeDefinition.Name.StringEquals(_name, reader)) { result = reflectionDomain.ResolveTypeDefinition(reader, candidateType); return(null); } } // No match found in this assembly - see if there's a matching type forwarder. IEnumerable <TypeForwarderHandle> candidateTypeForwarders = namespaceDefinition.TypeForwarders; foreach (TypeForwarderHandle typeForwarderHandle in candidateTypeForwarders) { TypeForwarder typeForwarder = typeForwarderHandle.GetTypeForwarder(reader); if (typeForwarder.Name.StringEquals(_name, reader)) { RuntimeAssemblyName redirectedAssemblyName = typeForwarder.Scope.ToRuntimeAssemblyName(reader); AssemblyQualifiedTypeName redirectedTypeName = new AssemblyQualifiedTypeName(this, redirectedAssemblyName); return(redirectedTypeName.TryResolve(reflectionDomain, null, /*ignoreCase: */ false, out result)); } } } { String typeName = this.ToString(); String message = SR.Format(SR.TypeLoad_TypeNotFound, typeName, currentAssembly.FullName); return(ReflectionCoreNonPortable.CreateTypeLoadException(message, typeName)); } }
private Exception TryResolveCaseInsensitive(ReflectionDomain reflectionDomain, RuntimeAssembly currentAssembly, out RuntimeType result) { String fullName = this.ToString().ToLower(); LowLevelDictionary <String, QHandle> dict = GetCaseInsensitiveTypeDictionary(currentAssembly); QHandle qualifiedHandle; if (!dict.TryGetValue(fullName, out qualifiedHandle)) { result = null; return(new TypeLoadException(SR.Format(SR.TypeLoad_TypeNotFound, this.ToString(), currentAssembly.FullName))); } MetadataReader reader = qualifiedHandle.Reader; Handle typeDefOrForwarderHandle = qualifiedHandle.Handle; HandleType handleType = typeDefOrForwarderHandle.HandleType; switch (handleType) { case HandleType.TypeDefinition: { TypeDefinitionHandle typeDefinitionHandle = typeDefOrForwarderHandle.ToTypeDefinitionHandle(reader); result = reflectionDomain.ResolveTypeDefinition(reader, typeDefinitionHandle); return(null); } case HandleType.TypeForwarder: { TypeForwarder typeForwarder = typeDefOrForwarderHandle.ToTypeForwarderHandle(reader).GetTypeForwarder(reader); ScopeReferenceHandle destinationScope = typeForwarder.Scope; RuntimeAssemblyName destinationAssemblyName = destinationScope.ToRuntimeAssemblyName(reader); RuntimeAssembly destinationAssembly; Exception exception = RuntimeAssembly.TryGetRuntimeAssembly(reflectionDomain, destinationAssemblyName, out destinationAssembly); if (exception != null) { result = null; return(exception); } return(TryResolveCaseInsensitive(reflectionDomain, destinationAssembly, out result)); } default: throw new InvalidOperationException(); } }
internal static RuntimeType TryResolve(this ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeDefRefOrSpec, TypeContext typeContext, ref Exception exception) { HandleType handleType = typeDefRefOrSpec.HandleType; if (handleType == HandleType.TypeDefinition) { return(reflectionDomain.ResolveTypeDefinition(reader, typeDefRefOrSpec.ToTypeDefinitionHandle(reader))); } else if (handleType == HandleType.TypeReference) { return(reflectionDomain.TryResolveTypeReference(reader, typeDefRefOrSpec.ToTypeReferenceHandle(reader), ref exception)); } else if (handleType == HandleType.TypeSpecification) { return(reflectionDomain.TryResolveTypeSignature(reader, typeDefRefOrSpec.ToTypeSpecificationHandle(reader), typeContext, ref exception)); } else { throw new BadImageFormatException(); // Expected TypeRef, Def or Spec. } }
private Exception TryResolveCaseInsensitive(ReflectionDomain reflectionDomain, RuntimeAssembly currentAssembly, out RuntimeType result) { String fullName = this.ToString().ToLower(); LowLevelDictionary<String, QHandle> dict = GetCaseInsensitiveTypeDictionary(currentAssembly); QHandle qualifiedHandle; if (!dict.TryGetValue(fullName, out qualifiedHandle)) { result = null; return new TypeLoadException(SR.Format(SR.TypeLoad_TypeNotFound, this.ToString(), currentAssembly.FullName)); } MetadataReader reader = qualifiedHandle.Reader; Handle typeDefOrForwarderHandle = qualifiedHandle.Handle; HandleType handleType = typeDefOrForwarderHandle.HandleType; switch (handleType) { case HandleType.TypeDefinition: { TypeDefinitionHandle typeDefinitionHandle = typeDefOrForwarderHandle.ToTypeDefinitionHandle(reader); result = reflectionDomain.ResolveTypeDefinition(reader, typeDefinitionHandle); return null; } case HandleType.TypeForwarder: { TypeForwarder typeForwarder = typeDefOrForwarderHandle.ToTypeForwarderHandle(reader).GetTypeForwarder(reader); ScopeReferenceHandle destinationScope = typeForwarder.Scope; RuntimeAssemblyName destinationAssemblyName = destinationScope.ToRuntimeAssemblyName(reader); RuntimeAssembly destinationAssembly; Exception exception = RuntimeAssembly.TryGetRuntimeAssembly(reflectionDomain, destinationAssemblyName, out destinationAssembly); if (exception != null) { result = null; return exception; } return TryResolveCaseInsensitive(reflectionDomain, destinationAssembly, out result); } default: throw new InvalidOperationException(); } }
private Exception UncachedTryResolveCaseSensitive(ReflectionDomain reflectionDomain, RuntimeAssembly currentAssembly, out RuntimeType result) { result = null; foreach (QScopeDefinition scopeDefinition in currentAssembly.AllScopes) { MetadataReader reader = scopeDefinition.Reader; ScopeDefinitionHandle scopeDefinitionHandle = scopeDefinition.Handle; NamespaceDefinition namespaceDefinition; if (!TryResolveNamespaceDefinitionCaseSensitive(reader, scopeDefinitionHandle, out namespaceDefinition)) { continue; } // We've successfully drilled down the namespace chain. Now look for a top-level type matching the type name. IEnumerable<TypeDefinitionHandle> candidateTypes = namespaceDefinition.TypeDefinitions; foreach (TypeDefinitionHandle candidateType in candidateTypes) { TypeDefinition typeDefinition = candidateType.GetTypeDefinition(reader); if (typeDefinition.Name.StringEquals(_name, reader)) { result = reflectionDomain.ResolveTypeDefinition(reader, candidateType); return null; } } // No match found in this assembly - see if there's a matching type forwarder. IEnumerable<TypeForwarderHandle> candidateTypeForwarders = namespaceDefinition.TypeForwarders; foreach (TypeForwarderHandle typeForwarderHandle in candidateTypeForwarders) { TypeForwarder typeForwarder = typeForwarderHandle.GetTypeForwarder(reader); if (typeForwarder.Name.StringEquals(_name, reader)) { RuntimeAssemblyName redirectedAssemblyName = typeForwarder.Scope.ToRuntimeAssemblyName(reader); AssemblyQualifiedTypeName redirectedTypeName = new AssemblyQualifiedTypeName(this, redirectedAssemblyName); return redirectedTypeName.TryResolve(reflectionDomain, null, /*ignoreCase: */false, out result); } } } { String typeName = this.ToString(); String message = SR.Format(SR.TypeLoad_TypeNotFound, typeName, currentAssembly.FullName); return ReflectionCoreNonPortable.CreateTypeLoadException(message, typeName); } }
// // Main routine to parse a metadata type specification signature. // private static RuntimeType TryResolveTypeSignature(this ReflectionDomain reflectionDomain, MetadataReader reader, TypeSpecificationHandle typeSpecHandle, TypeContext typeContext, ref Exception exception) { Handle typeHandle = typeSpecHandle.GetTypeSpecification(reader).Signature; switch (typeHandle.HandleType) { case HandleType.ArraySignature: { ArraySignature sig = typeHandle.ToArraySignatureHandle(reader).GetArraySignature(reader); int rank = sig.Rank; if (rank <= 0) { throw new BadImageFormatException(); // Bad rank. } RuntimeType elementType = reflectionDomain.TryResolve(reader, sig.ElementType, typeContext, ref exception); if (elementType == null) { return(null); } return(ReflectionCoreNonPortable.GetMultiDimArrayType(elementType, rank)); } case HandleType.ByReferenceSignature: { ByReferenceSignature sig = typeHandle.ToByReferenceSignatureHandle(reader).GetByReferenceSignature(reader); RuntimeType targetType = reflectionDomain.TryResolve(reader, sig.Type, typeContext, ref exception); if (targetType == null) { return(null); } return(ReflectionCoreNonPortable.GetByRefType(targetType)); } case HandleType.MethodTypeVariableSignature: { MethodTypeVariableSignature sig = typeHandle.ToMethodTypeVariableSignatureHandle(reader).GetMethodTypeVariableSignature(reader); return(typeContext.GenericMethodArguments[sig.Number]); } case HandleType.PointerSignature: { PointerSignature sig = typeHandle.ToPointerSignatureHandle(reader).GetPointerSignature(reader); RuntimeType targetType = reflectionDomain.TryResolve(reader, sig.Type, typeContext, ref exception); if (targetType == null) { return(null); } return(ReflectionCoreNonPortable.GetPointerType(targetType)); } case HandleType.SZArraySignature: { SZArraySignature sig = typeHandle.ToSZArraySignatureHandle(reader).GetSZArraySignature(reader); RuntimeType elementType = reflectionDomain.TryResolve(reader, sig.ElementType, typeContext, ref exception); if (elementType == null) { return(null); } return(ReflectionCoreNonPortable.GetArrayType(elementType)); } case HandleType.TypeDefinition: { return(reflectionDomain.ResolveTypeDefinition(reader, typeHandle.ToTypeDefinitionHandle(reader))); } case HandleType.TypeInstantiationSignature: { TypeInstantiationSignature sig = typeHandle.ToTypeInstantiationSignatureHandle(reader).GetTypeInstantiationSignature(reader); RuntimeType genericTypeDefinition = reflectionDomain.TryResolve(reader, sig.GenericType, typeContext, ref exception); if (genericTypeDefinition == null) { return(null); } LowLevelList <RuntimeType> genericTypeArguments = new LowLevelList <RuntimeType>(); foreach (Handle genericTypeArgumentHandle in sig.GenericTypeArguments) { RuntimeType genericTypeArgument = reflectionDomain.TryResolve(reader, genericTypeArgumentHandle, typeContext, ref exception); if (genericTypeArgument == null) { return(null); } genericTypeArguments.Add(genericTypeArgument); } return(ReflectionCoreNonPortable.GetConstructedGenericType(genericTypeDefinition, genericTypeArguments.ToArray())); } case HandleType.TypeReference: { return(reflectionDomain.TryResolveTypeReference(reader, typeHandle.ToTypeReferenceHandle(reader), ref exception)); } case HandleType.TypeVariableSignature: { TypeVariableSignature sig = typeHandle.ToTypeVariableSignatureHandle(reader).GetTypeVariableSignature(reader); return(typeContext.GenericTypeArguments[sig.Number]); } default: throw new NotSupportedException(); // Unexpected Type signature type. } }