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();
}
}
