public sealed override Assembly Load(AssemblyName assemblyRef, bool throwOnFileNotFound) { if (assemblyRef == null) throw new ArgumentNullException(nameof(assemblyRef)); if (throwOnFileNotFound) return RuntimeAssemblyInfo.GetRuntimeAssembly(assemblyRef.ToRuntimeAssemblyName()); else return RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(assemblyRef.ToRuntimeAssemblyName()); }
internal sealed override RuntimeTypeInfo UncachedGetTypeCoreCaseSensitive(string fullName) { string[] parts = fullName.Split('.'); int numNamespaceParts = parts.Length - 1; string[] namespaceParts = new string[numNamespaceParts]; for (int i = 0; i < numNamespaceParts; i++) { namespaceParts[numNamespaceParts - i - 1] = parts[i]; } string name = parts[numNamespaceParts]; foreach (QScopeDefinition scopeDefinition in AllScopes) { MetadataReader reader = scopeDefinition.Reader; ScopeDefinitionHandle scopeDefinitionHandle = scopeDefinition.Handle; NamespaceDefinition namespaceDefinition; if (!TryResolveNamespaceDefinitionCaseSensitive(reader, namespaceParts, scopeDefinitionHandle, out namespaceDefinition)) { continue; } // We've successfully drilled down the namespace chain. Now look for a top-level type matching the type name. TypeDefinitionHandleCollection candidateTypes = namespaceDefinition.TypeDefinitions; foreach (TypeDefinitionHandle candidateType in candidateTypes) { TypeDefinition typeDefinition = candidateType.GetTypeDefinition(reader); if (typeDefinition.Name.StringEquals(name, reader)) { return(candidateType.ResolveTypeDefinition(reader)); } } // No match found in this assembly - see if there's a matching type forwarder. TypeForwarderHandleCollection 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); RuntimeAssemblyInfo redirectedAssembly = RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(redirectedAssemblyName); if (redirectedAssembly == null) { return(null); } return(redirectedAssembly.GetTypeCoreCaseSensitive(fullName)); } } } return(null); }
private static CoreTypeResolver CreateCoreTypeResolver(Func <Assembly, string, bool, Type> typeResolver, IList <string> defaultAssemblyNames, bool throwOnError, bool ignoreCase) { if (typeResolver == null) { return(delegate(Assembly containingAssemblyIfAny, string coreTypeName) { if (containingAssemblyIfAny != null) { return containingAssemblyIfAny.GetTypeCore(coreTypeName, ignoreCase: ignoreCase); } else { foreach (string defaultAssemblyName in defaultAssemblyNames) { RuntimeAssemblyName runtimeAssemblyName = RuntimeAssemblyName.Parse(defaultAssemblyName); RuntimeAssemblyInfo defaultAssembly = RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(runtimeAssemblyName); if (defaultAssembly == null) { continue; } Type resolvedType = defaultAssembly.GetTypeCore(coreTypeName, ignoreCase: ignoreCase); if (resolvedType != null) { return resolvedType; } } if (throwOnError && defaultAssemblyNames.Count > 0) { // Though we don't have to throw a TypeLoadException exception (that's our caller's job), we can throw a more specific exception than he would so just do it. throw Helpers.CreateTypeLoadException(coreTypeName, defaultAssemblyNames[0]); } return null; } }); } else { return(delegate(Assembly containingAssemblyIfAny, string coreTypeName) { string escapedName = coreTypeName.EscapeTypeNameIdentifier(); Type type = typeResolver(containingAssemblyIfAny, escapedName, ignoreCase); return type; }); } }
internal sealed override RuntimeTypeInfo GetTypeCoreCaseInsensitive(string fullName) { LowLevelDictionary <string, QHandle> dict = CaseInsensitiveTypeDictionary; QHandle qualifiedHandle; if (!dict.TryGetValue(fullName.ToLowerInvariant(), out qualifiedHandle)) { return(null); } MetadataReader reader = qualifiedHandle.Reader; Handle typeDefOrForwarderHandle = qualifiedHandle.Handle; HandleType handleType = typeDefOrForwarderHandle.HandleType; switch (handleType) { case HandleType.TypeDefinition: { TypeDefinitionHandle typeDefinitionHandle = typeDefOrForwarderHandle.ToTypeDefinitionHandle(reader); return(typeDefinitionHandle.ResolveTypeDefinition(reader)); } case HandleType.TypeForwarder: { TypeForwarder typeForwarder = typeDefOrForwarderHandle.ToTypeForwarderHandle(reader).GetTypeForwarder(reader); ScopeReferenceHandle destinationScope = typeForwarder.Scope; RuntimeAssemblyName destinationAssemblyName = destinationScope.ToRuntimeAssemblyName(reader); RuntimeAssemblyInfo destinationAssembly = RuntimeAssemblyInfo.GetRuntimeAssemblyIfExists(destinationAssemblyName); if (destinationAssembly == null) { return(null); } return(destinationAssembly.GetTypeCoreCaseInsensitive(fullName)); } default: throw new InvalidOperationException(); } }