public AssemblyQualifiedTypeName(NonQualifiedTypeName nonQualifiedTypeName, RuntimeAssemblyName assemblyName)
{
Debug.Assert(nonQualifiedTypeName != null);
Debug.Assert(assemblyName != null);
_nonQualifiedTypeName = nonQualifiedTypeName;
_assemblyName = assemblyName;
}
public AssemblyQualifiedTypeName(NonQualifiedTypeName nonQualifiedTypeName, RuntimeAssemblyName assemblyName)
{
Debug.Assert(nonQualifiedTypeName != null);
Debug.Assert(assemblyName != null);
_nonQualifiedTypeName = nonQualifiedTypeName;
_assemblyName = assemblyName;
}
//
// Encapsulates the assembly ref->def matching policy.
//
private static bool AssemblyNameMatches(RuntimeAssemblyName refName, RuntimeAssemblyName defName, ref Exception preferredException)
{
//
// The defName came from trusted metadata so it should be fully specified.
//
Debug.Assert(defName.Version != null);
Debug.Assert(defName.CultureName != null);
if (!(refName.Name.Equals(defName.Name, StringComparison.OrdinalIgnoreCase)))
{
return(false);
}
if (refName.Version != null)
{
if (!AssemblyVersionMatches(refVersion: refName.Version, defVersion: defName.Version))
{
preferredException = new FileLoadException(SR.Format(SR.FileLoadException_RefDefMismatch, refName.FullName, defName.Version, refName.Version));
return(false);
}
}
if (refName.CultureName != null)
{
if (!(refName.CultureName.Equals(defName.CultureName)))
{
return(false);
}
}
// Strong names are ignored in .NET Core
return(true);
}
//
// Lex the next segment as an assembly name embedded inside a generic argument type.
//
// Terminated by an unescaped ']'.
//
public RuntimeAssemblyName GetNextEmbeddedAssemblyName()
{
SkipWhiteSpace();
int src = _index;
char[] buffer = new char[_chars.Length];
int dst = 0;
for (;;)
{
char c = _chars[src];
if (c == NUL)
{
throw new ArgumentException();
}
if (c == ']')
{
break;
}
src++;
// Backslash can be used to escape a ']' - any other backslash character is left alone (along with the backslash)
// for the AssemblyName parser to handle.
if (c == '\\' && _chars[src] == ']')
{
c = _chars[src++];
}
buffer[dst++] = c;
}
_index = src;
string fullName = new string(buffer, 0, dst);
return(RuntimeAssemblyName.Parse(fullName));
}
public PEInfo(RuntimeAssemblyName name, MetadataReader?reader, PEReader?pe, MemoryMappedViewAccessor?memoryMappedView = null)
{
Name = name;
Reader = reader;
PE = pe;
MemoryMappedView = memoryMappedView;
}
//
// Name match routine for mscorlib references
//
private bool MscorlibAssemblyNameMatches(RuntimeAssemblyName coreAssemblyName, RuntimeAssemblyName defName)
{
//
// The defName came from trusted metadata so it should be fully specified.
//
Debug.Assert(defName.Version != null);
Debug.Assert(defName.CultureName != null);
Debug.Assert((coreAssemblyName.Flags & AssemblyNameFlags.PublicKey) == 0);
Debug.Assert((defName.Flags & AssemblyNameFlags.PublicKey) == 0);
if (defName.Name != coreAssemblyName.Name)
{
return(false);
}
byte[] defPkt = defName.PublicKeyOrToken;
if (defPkt == null)
{
return(false);
}
if (!ArePktsEqual(defPkt, coreAssemblyName.PublicKeyOrToken))
{
return(false);
}
return(true);
}
public NativeFormatModule GetModuleFromAssemblyName(string assemblyNameString)
{
AssemblyBindResult bindResult;
RuntimeAssemblyName assemblyName = AssemblyNameParser.Parse(assemblyNameString);
Exception failureException;
if (!AssemblyBinderImplementation.Instance.Bind(assemblyName, cacheMissedLookups: true, out bindResult, out failureException))
{
throw failureException;
}
var moduleList = Internal.Runtime.TypeLoader.ModuleList.Instance;
NativeFormatModuleInfo primaryModule = moduleList.GetModuleInfoForMetadataReader(bindResult.Reader);
// If this isn't the primary module, defer to that module to load the MetadataUnit
if (primaryModule != _module)
{
return(Context.ResolveMetadataUnit(primaryModule).GetModule(bindResult.ScopeDefinitionHandle));
}
// Setup arguments and allocate the NativeFormatModule
ArrayBuilder <NativeFormatModule.QualifiedScopeDefinition> qualifiedScopes = new ArrayBuilder <NativeFormatModule.QualifiedScopeDefinition>();
qualifiedScopes.Add(new NativeFormatModule.QualifiedScopeDefinition(this, bindResult.ScopeDefinitionHandle));
foreach (QScopeDefinition scope in bindResult.OverflowScopes)
{
NativeFormatModuleInfo module = moduleList.GetModuleInfoForMetadataReader(scope.Reader);
ScopeDefinitionHandle scopeHandle = scope.Handle;
NativeFormatMetadataUnit metadataUnit = Context.ResolveMetadataUnit(module);
qualifiedScopes.Add(new NativeFormatModule.QualifiedScopeDefinition(metadataUnit, scopeHandle));
}
return(new NativeFormatModule(Context, qualifiedScopes.ToArray()));
}
//
// Parse a generic argument. In particular, generic arguments can take the special form [<typename>,<assemblyname>].
//
private TypeName ParseGenericTypeArgument()
{
TokenType token = _lexer.GetNextToken();
if (token == TokenType.Other)
{
NonQualifiedTypeName nonQualifiedTypeName = ParseNonQualifiedTypeName();
return(new AssemblyQualifiedTypeName(nonQualifiedTypeName, null));
}
else if (token == TokenType.OpenSqBracket)
{
RuntimeAssemblyName assemblyName = null;
NonQualifiedTypeName typeName = ParseNonQualifiedTypeName();
token = _lexer.GetNextToken();
if (token == TokenType.Comma)
{
assemblyName = _lexer.GetNextEmbeddedAssemblyName();
token = _lexer.GetNextToken();
}
if (token != TokenType.CloseSqBracket)
{
throw new ArgumentException();
}
return(new AssemblyQualifiedTypeName(typeName, assemblyName));
}
else
{
throw new ArgumentException();
}
}
public Assembly CoreResolveAssembly(RuntimeAssemblyName name)
{
Assembly assembly = _coreAssemblyResolver(name);
if (assembly == null && ThrowOnError)
throw new FileNotFoundException(SR.Format(SR.FileNotFound_AssemblyNotFound, name.FullName));
return assembly;
}
public IEnumerable <string> FilePathsForAssembly(RuntimeAssemblyName refName)
{
// Check for illegal characters in file name
if (refName.Name.IndexOfAny(Path.GetInvalidFileNameChars()) != -1)
{
yield break;
}
// Implement simple probing for assembly in application base directory and culture specific directory
string probingDirectory = AppContext.BaseDirectory;
string cultureQualifiedDirectory = probingDirectory;
if (!String.IsNullOrEmpty(refName.CultureName))
{
cultureQualifiedDirectory = Path.Combine(probingDirectory, refName.CultureName);
}
else
{
// Loading non-resource dlls not yet supported
yield break;
}
// Attach assembly name
yield return(Path.Combine(cultureQualifiedDirectory, refName.Name + ".dll"));
}
private unsafe InternalManifestResourceInfo GetInternalManifestResourceInfo(string resourceName)
{
InternalManifestResourceInfo result = new InternalManifestResourceInfo();
ManifestResourceHandleCollection manifestResources = MetadataReader.ManifestResources;
foreach (var resourceHandle in manifestResources)
{
ManifestResource resource = MetadataReader.GetManifestResource(resourceHandle);
if (MetadataReader.StringComparer.Equals(resource.Name, resourceName))
{
result.Found = true;
if (resource.Implementation.IsNil)
{
checked
{
// Embedded data resource
result.ResourceLocation = ResourceLocation.Embedded | ResourceLocation.ContainedInManifestFile;
PEReader pe = PEReader;
PEMemoryBlock resourceDirectory = pe.GetSectionData(pe.PEHeaders.CorHeader.ResourcesDirectory.RelativeVirtualAddress);
BlobReader reader = resourceDirectory.GetReader((int)resource.Offset, resourceDirectory.Length - (int)resource.Offset);
uint length = reader.ReadUInt32();
result.PointerToResource = reader.CurrentPointer;
// Length check the size of the resource to ensure it fits in the PE file section, note, this is only safe as its in a checked region
if (length + sizeof(Int32) > reader.Length)
{
throw new BadImageFormatException();
}
result.SizeOfResource = length;
}
}
else
{
if (resource.Implementation.Kind == HandleKind.AssemblyFile)
{
// Get file name
result.ResourceLocation = default(ResourceLocation);
AssemblyFile file = MetadataReader.GetAssemblyFile((AssemblyFileHandle)resource.Implementation);
if (file.ContainsMetadata)
{
result.ResourceLocation = ResourceLocation.Embedded;
throw new PlatformNotSupportedException(); // Support for multi-module assemblies is not implemented on this platform
}
result.FileName = MetadataReader.GetString(file.Name);
}
else if (resource.Implementation.Kind == HandleKind.AssemblyReference)
{
// Resolve assembly reference
result.ResourceLocation = ResourceLocation.ContainedInAnotherAssembly;
RuntimeAssemblyName destinationAssemblyName = ((AssemblyReferenceHandle)resource.Implementation).ToRuntimeAssemblyName(MetadataReader);
result.ReferencedAssembly = RuntimeAssembly.GetRuntimeAssemblyIfExists(destinationAssemblyName);
}
}
}
}
return(result);
}
internal static String ComputeDisplayName(RuntimeAssemblyName a)
{
if (a.Name == String.Empty)
throw new FileLoadException();
StringBuilder sb = new StringBuilder();
if (a.Name != null)
{
sb.AppendQuoted(a.Name);
}
if (a.Version != null)
{
sb.Append(", Version=");
sb.Append(a.Version.ToString());
}
String cultureName = a.CultureName;
if (cultureName != null)
{
if (cultureName == String.Empty)
cultureName = "neutral";
sb.Append(", Culture=");
sb.AppendQuoted(cultureName);
}
byte[] pkt = a.PublicKeyOrToken;
if (pkt != null)
{
if (0 != (a.Flags & AssemblyNameFlags.PublicKey))
pkt = ComputePublicKeyToken(pkt);
if (pkt.Length > PUBLIC_KEY_TOKEN_LEN)
throw new ArgumentException();
sb.Append(", PublicKeyToken=");
if (pkt.Length == 0)
sb.Append("null");
else
{
foreach (byte b in pkt)
{
sb.Append(b.ToString("x2", CultureInfo.InvariantCulture));
}
}
}
if (0 != (a.Flags & AssemblyNameFlags.Retargetable))
sb.Append(", Retargetable=Yes");
AssemblyContentType contentType = ExtractAssemblyContentType(a.Flags);
if (contentType == AssemblyContentType.WindowsRuntime)
sb.Append(", ContentType=WindowsRuntime");
// NOTE: By design (desktop compat) AssemblyName.FullName and ToString() do not include ProcessorArchitecture.
return sb.ToString();
}
//
// Encapsulates the assembly ref->def matching policy.
//
private bool AssemblyNameMatches(RuntimeAssemblyName refName, RuntimeAssemblyName defName)
{
//
// The defName came from trusted metadata so it should be fully specified.
//
Debug.Assert(defName.Version != null);
Debug.Assert(defName.CultureName != null);
Debug.Assert((defName.Flags & AssemblyNameFlags.PublicKey) == 0);
Debug.Assert((refName.Flags & AssemblyNameFlags.PublicKey) == 0);
if (!(refName.Name.Equals(defName.Name, StringComparison.OrdinalIgnoreCase)))
{
return(false);
}
if (refName.Version != null)
{
int compareResult = refName.Version.CompareTo(defName.Version);
if (compareResult > 0)
{
return(false);
}
}
if (refName.CultureName != null)
{
if (!(refName.CultureName.Equals(defName.CultureName)))
{
return(false);
}
}
AssemblyNameFlags materialRefNameFlags = refName.Flags.ExtractAssemblyNameFlags();
AssemblyNameFlags materialDefNameFlags = defName.Flags.ExtractAssemblyNameFlags();
if (materialRefNameFlags != materialDefNameFlags)
{
return(false);
}
byte[] refPublicKeyToken = refName.PublicKeyOrToken;
if (refPublicKeyToken != null)
{
byte[] defPublicKeyToken = defName.PublicKeyOrToken;
if (defPublicKeyToken == null)
{
return(false);
}
if (!ArePktsEqual(refPublicKeyToken, defPublicKeyToken))
{
return(false);
}
}
return(true);
}
//
// Encapsulates the assembly ref->def matching policy.
//
private bool AssemblyNameMatches(RuntimeAssemblyName refName, RuntimeAssemblyName defName, ref Exception preferredException)
{
//
// The defName came from trusted metadata so it should be fully specified.
//
Debug.Assert(defName.Version != null);
Debug.Assert(defName.CultureName != null);
Debug.Assert((defName.Flags & AssemblyNameFlags.PublicKey) == 0);
Debug.Assert((refName.Flags & AssemblyNameFlags.PublicKey) == 0);
if (!(refName.Name.Equals(defName.Name, StringComparison.OrdinalIgnoreCase)))
{
return(false);
}
if (refName.Version != null)
{
if (!AssemblyVersionMatches(refVersion: refName.Version, defVersion: defName.Version))
{
preferredException = new FileLoadException(SR.Format(SR.FileLoadException_RefDefMismatch, refName.FullName, defName.Version, refName.Version));
return(false);
}
}
if (refName.CultureName != null)
{
if (!(refName.CultureName.Equals(defName.CultureName)))
{
return(false);
}
}
AssemblyNameFlags materialRefNameFlags = refName.Flags.ExtractAssemblyNameFlags();
AssemblyNameFlags materialDefNameFlags = defName.Flags.ExtractAssemblyNameFlags();
if (materialRefNameFlags != materialDefNameFlags)
{
return(false);
}
byte[] refPublicKeyToken = refName.PublicKeyOrToken;
if (refPublicKeyToken != null)
{
byte[] defPublicKeyToken = defName.PublicKeyOrToken;
if (defPublicKeyToken == null)
{
return(false);
}
if (!ArePktsEqual(refPublicKeyToken, defPublicKeyToken))
{
return(false);
}
}
return(true);
}
public Assembly CoreResolveAssembly(RuntimeAssemblyName name)
{
Assembly assembly = _coreAssemblyResolver(name);
if (assembly == null && ThrowOnError)
{
throw new FileNotFoundException(SR.Format(SR.FileNotFound_AssemblyNotFound, name.FullName));
}
return(assembly);
}
public TypeForwardInfo(RuntimeAssemblyName redirectedAssemblyName, string namespaceName, string typeName)
{
Debug.Assert(redirectedAssemblyName != null);
Debug.Assert(namespaceName != null);
Debug.Assert(typeName != null);
RedirectedAssemblyName = redirectedAssemblyName;
NamespaceName = namespaceName;
TypeName = typeName;
}
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 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));
}
}
//
// Parses a typename. The typename may be optionally postpended with a "," followed by a legal assembly name.
//
private static TypeName ParseAssemblyQualifiedTypeName(String s)
{
if (string.IsNullOrEmpty(s))
{
return(null);
}
// Desktop compat: a whitespace-only "typename" qualified by an assembly name throws an ArgumentException rather than
// a TypeLoadException.
int idx = 0;
while (idx < s.Length && Char.IsWhiteSpace(s[idx]))
{
idx++;
}
if (idx < s.Length && s[idx] == ',')
{
throw new ArgumentException();
}
try
{
TypeParser parser = new TypeParser(s);
NonQualifiedTypeName typeName = parser.ParseNonQualifiedTypeName();
TokenType token = parser._lexer.GetNextToken();
if (token == TokenType.End)
{
return(typeName);
}
if (token == TokenType.Comma)
{
RuntimeAssemblyName assemblyName = parser._lexer.GetNextAssemblyName();
token = parser._lexer.Peek;
if (token != TokenType.End)
{
throw new ArgumentException();
}
return(new AssemblyQualifiedTypeName(typeName, assemblyName));
}
throw new ArgumentException();
}
catch (TypeLexer.IllegalEscapeSequenceException)
{
// Emulates a CLR4.5 bug that causes any string that contains an illegal escape sequence to be parsed as the empty string.
return(ParseAssemblyQualifiedTypeName(String.Empty));
}
}
private static void AddScopesFromReaderToGroups(LowLevelDictionaryWithIEnumerable <RuntimeAssemblyName, ScopeDefinitionGroup> groups, MetadataReader reader)
{
foreach (ScopeDefinitionHandle scopeDefinitionHandle in reader.ScopeDefinitions)
{
RuntimeAssemblyName defName = scopeDefinitionHandle.ToRuntimeAssemblyName(reader);
ScopeDefinitionGroup scopeDefinitionGroup;
if (groups.TryGetValue(defName, out scopeDefinitionGroup))
{
scopeDefinitionGroup.AddOverflowScope(new QScopeDefinition(reader, scopeDefinitionHandle));
}
else
{
scopeDefinitionGroup = new ScopeDefinitionGroup(new QScopeDefinition(reader, scopeDefinitionHandle));
groups.Add(defName, scopeDefinitionGroup);
}
}
}
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;
});
}
}
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();
}
}
partial void BindEcmaByteArray(byte[] rawAssembly, byte[] rawSymbolStore, ref AssemblyBindResult bindResult, ref Exception exception, ref bool?result)
{
// 1. Load byte[] into immutable array for use by PEReader/MetadataReader
ImmutableArray <byte> assemblyData = ImmutableArray.Create(rawAssembly);
PEReader pe = new PEReader(assemblyData);
MetadataReader reader = pe.GetMetadataReader();
// 2. Create AssemblyName from MetadataReader
RuntimeAssemblyName runtimeAssemblyName = reader.GetAssemblyDefinition().ToRuntimeAssemblyName(reader);
AssemblyName asmName = new AssemblyName();
runtimeAssemblyName.CopyToAssemblyName(asmName);
lock (s_ecmaLoadedAssemblies)
{
// 3. Attempt to bind to already loaded assembly
if (Bind(asmName, out bindResult, out exception))
{
result = true;
return;
}
exception = null;
// 4. If that fails, then add newly created metareader to global cache of byte array loaded modules
PEInfo peinfo = new PEInfo(asmName, reader, pe);
s_ecmaLoadedAssemblies.Add(peinfo);
ModuleList moduleList = ModuleList.Instance;
ModuleInfo newModuleInfo = new EcmaModuleInfo(moduleList.SystemModule.Handle, pe, reader);
moduleList.RegisterModule(newModuleInfo);
// 5. Then try to load by name again. This load should always succeed
if (Bind(asmName, out bindResult, out exception))
{
result = true;
return;
}
result = false;
Debug.Assert(exception != null); // We must have an error on load. At this time this could happen due to ambiguous name matching
}
}
public sealed override bool Bind(RuntimeAssemblyName refName, bool cacheMissedLookups, out AssemblyBindResult result, out Exception exception)
{
bool foundMatch = false;
result = default(AssemblyBindResult);
exception = null;
Exception preferredException = null;
foreach (KeyValuePair <RuntimeAssemblyName, ScopeDefinitionGroup> group in ScopeGroups)
{
if (AssemblyNameMatches(refName, group.Key, ref preferredException))
{
if (foundMatch)
{
exception = new AmbiguousMatchException();
return(false);
}
foundMatch = true;
ScopeDefinitionGroup scopeDefinitionGroup = group.Value;
result.Reader = scopeDefinitionGroup.CanonicalScope.Reader;
result.ScopeDefinitionHandle = scopeDefinitionGroup.CanonicalScope.Handle;
result.OverflowScopes = scopeDefinitionGroup.OverflowScopes;
}
}
BindEcmaAssemblyName(refName, cacheMissedLookups, ref result, ref exception, ref preferredException, ref foundMatch);
if (exception != null)
{
return(false);
}
if (!foundMatch)
{
exception = preferredException ?? new FileNotFoundException(SR.Format(SR.FileNotFound_AssemblyNotFound, refName.FullName));
return(false);
}
return(true);
}
partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, ref AssemblyBindResult result, ref Exception exception, ref bool foundMatch)
{
lock (s_ecmaLoadedAssemblies)
{
for (int i = 0; i < s_ecmaLoadedAssemblies.Count; i++)
{
PEInfo info = s_ecmaLoadedAssemblies[i];
if (AssemblyNameMatches(refName, info.Name))
{
if (foundMatch)
{
exception = new AmbiguousMatchException();
return;
}
foundMatch = true;
result.EcmaMetadataReader = info.Reader;
}
}
}
}
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();
}
}
public static AssemblyQualifiedTypeName ToAssemblyQualifiedTypeName(this NamespaceReferenceHandle namespaceReferenceHandle, String typeName, MetadataReader reader)
{
LowLevelList <String> namespaceParts = new LowLevelList <String>(8);
NamespaceReference namespaceReference;
for (; ;)
{
namespaceReference = namespaceReferenceHandle.GetNamespaceReference(reader);
String namespacePart = namespaceReference.Name.GetStringOrNull(reader);
if (namespacePart == null)
{
break;
}
namespaceParts.Add(namespacePart);
namespaceReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToExpectedNamespaceReferenceHandle(reader);
}
ScopeReferenceHandle scopeReferenceHandle = namespaceReference.ParentScopeOrNamespace.ToExpectedScopeReferenceHandle(reader);
RuntimeAssemblyName assemblyName = scopeReferenceHandle.ToRuntimeAssemblyName(reader);
return(new AssemblyQualifiedTypeName(new NamespaceTypeName(namespaceParts.ToArray(), typeName), assemblyName));
}
//
// Lex the next segment as the assembly name at the end of an assembly-qualified type name. (Do not use for
// assembly names embedded inside generic type arguments.)
//
// Terminated by NUL. There are no escape characters defined by the typename lexer (however, AssemblyName
// does have its own escape rules.)
//
public RuntimeAssemblyName GetNextAssemblyName()
{
SkipWhiteSpace();
int src = _index;
char[] buffer = new char[_chars.Length];
int dst = 0;
for (;;)
{
char c = _chars[src];
if (c == NUL)
{
break;
}
src++;
buffer[dst++] = c;
}
_index = src;
string fullName = new string(buffer, 0, dst);
return(RuntimeAssemblyName.Parse(fullName));
}
private void BindEcma(PEReader pe, MemoryMappedViewAccessor?memoryMappedView, out AssemblyBindResult bindResult, out Exception?exception, out bool?result)
{
MetadataReader reader = pe.GetMetadataReader();
// 1. Create AssemblyName from MetadataReader
RuntimeAssemblyName runtimeAssemblyName = reader.GetAssemblyDefinition().ToRuntimeAssemblyName(reader);
lock (s_ecmaLoadedAssemblies)
{
// 2. Attempt to bind to already loaded assembly
if (Bind(runtimeAssemblyName, cacheMissedLookups: false, out bindResult, out exception))
{
result = true;
return;
}
exception = null;
// 3. If that fails, then add newly created metareader to global cache of loaded modules
PEInfo peinfo = new PEInfo(runtimeAssemblyName, reader, pe, memoryMappedView);
s_ecmaLoadedAssemblies.Add(peinfo);
ModuleList moduleList = ModuleList.Instance;
ModuleInfo newModuleInfo = new EcmaModuleInfo(moduleList.SystemModule.Handle, pe, reader);
moduleList.RegisterModule(newModuleInfo);
// 4. Then try to load by name again. This load should always succeed
if (Bind(runtimeAssemblyName, cacheMissedLookups: true, out bindResult, out exception))
{
result = true;
return;
}
result = false;
Debug.Assert(exception != null); // We must have an error on load. At this time this could happen due to ambiguous name matching
}
}
public sealed override void InitializeAssemblyName(AssemblyName blank, String fullName)
{
RuntimeAssemblyName runtimeAssemblyName = AssemblyNameParser.Parse(fullName);
runtimeAssemblyName.CopyToAssemblyName(blank);
}
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.
}
partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, bool cacheMissedLookups, ref AssemblyBindResult result, ref Exception exception, ref Exception preferredException, ref bool resultBoolean);
public AssemblyQualifiedTypeName(NonQualifiedTypeName typeName, RuntimeAssemblyName assemblyName)
{
Debug.Assert(typeName != null);
TypeName = typeName;
AssemblyName = assemblyName;
}
public PEInfo(RuntimeAssemblyName name, MetadataReader reader, PEReader pe)
{
Name = name;
Reader = reader;
PE = pe;
}
