private 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.
IEnumerable <TypeDefinitionHandle> 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.
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);
RuntimeAssembly redirectedAssembly = RuntimeAssembly.GetRuntimeAssemblyIfExists(redirectedAssemblyName);
if (redirectedAssemblyName == null)
{
return(null);
}
return(redirectedAssembly.GetTypeCoreCaseSensitive(fullName));
}
}
}
return(null);
}
private RuntimeTypeInfo GetTypeCoreCaseInsensitive(string fullName)
{
LowLevelDictionary <string, QHandle> dict = CaseInsensitiveTypeDictionary;
QHandle qualifiedHandle;
if (!dict.TryGetValue(fullName.ToLower(), 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);
RuntimeAssembly destinationAssembly = RuntimeAssembly.GetRuntimeAssemblyIfExists(destinationAssemblyName);
if (destinationAssembly == null)
{
return(null);
}
return(destinationAssembly.GetTypeCoreCaseInsensitive(fullName));
}
default:
throw new InvalidOperationException();
}
}
