private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata(
MetadataReader reader,
ConstantStringValueHandle name,
ushort majorVersion,
ushort minorVersion,
ushort buildNumber,
ushort revisionNumber,
ConstantStringValueHandle culture,
IEnumerable <byte> publicKeyOrToken,
AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if (0 != (assemblyFlags & AssemblyFlags.PublicKey))
{
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
}
if (0 != (assemblyFlags & AssemblyFlags.Retargetable))
{
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
}
int contentType = ((int)assemblyFlags) & 0x00000E00;
assemblyNameFlags |= (AssemblyNameFlags)contentType;
return(new RuntimeAssemblyName(
name.GetString(reader),
new Version(majorVersion, minorVersion, buildNumber, revisionNumber),
culture.GetStringOrNull(reader),
assemblyNameFlags,
publicKeyOrToken.ToArray()
));
}
public sealed override string InternalGetNameIfAvailable(ref Type rootCauseForFailure)
{
ConstantStringValueHandle nameHandle = _typeDefinition.Name;
string name = nameHandle.GetString(_reader);
return(name.EscapeTypeNameIdentifier());
}
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata(
MetadataReader reader,
ConstantStringValueHandle name,
ushort majorVersion,
ushort minorVersion,
ushort buildNumber,
ushort revisionNumber,
ConstantStringValueHandle culture,
IEnumerable<byte> publicKeyOrToken,
AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if (0 != (assemblyFlags & AssemblyFlags.PublicKey))
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
if (0 != (assemblyFlags & AssemblyFlags.Retargetable))
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
int contentType = ((int)assemblyFlags) & 0x00000E00;
assemblyNameFlags |= (AssemblyNameFlags)contentType;
ArrayBuilder<byte> keyOrTokenArrayBuilder = new ArrayBuilder<byte>();
foreach (byte b in publicKeyOrToken)
keyOrTokenArrayBuilder.Add(b);
return new RuntimeAssemblyName(
name.GetString(reader),
new Version(majorVersion, minorVersion, buildNumber, revisionNumber),
culture.GetStringOrNull(reader),
assemblyNameFlags,
keyOrTokenArrayBuilder.ToArray()
);
}
// Useful for namespace Name string which can be a null handle.
public static String GetStringOrNull(this ConstantStringValueHandle handle, MetadataReader reader)
{
if (reader.IsNull(handle))
{
return(null);
}
return(reader.GetConstantStringValue(handle).Value);
}
// This is specially designed for a hot path so we make some compromises in the signature:
//
// - "method" is passed by reference even though no side-effects are intended.
//
public static bool IsConstructor(ref Method method, MetadataReader reader)
{
if ((method.Flags & (MethodAttributes.RTSpecialName | MethodAttributes.SpecialName)) != (MethodAttributes.RTSpecialName | MethodAttributes.SpecialName))
{
return(false);
}
ConstantStringValueHandle nameHandle = method.Name;
return(nameHandle.StringEquals(ConstructorInfo.ConstructorName, reader) || nameHandle.StringEquals(ConstructorInfo.TypeConstructorName, reader));
}
public static bool StringOrNullEquals(this ConstantStringValueHandle handle, String valueOrNull, MetadataReader reader)
{
if (valueOrNull == null)
{
return(handle.IsNull(reader));
}
if (handle.IsNull(reader))
{
return(false);
}
return(handle.StringEquals(valueOrNull, reader));
}
public static bool GetAttributeNamespaceAndName(this MetadataReader metadataReader, CustomAttributeHandle attributeHandle,
out string namespaceString, out ConstantStringValueHandle nameHandle)
{
Handle attributeType, attributeCtor;
if (!GetAttributeTypeAndConstructor(metadataReader, attributeHandle, out attributeType, out attributeCtor))
{
namespaceString = null;
nameHandle = default(ConstantStringValueHandle);
return(false);
}
return(GetAttributeTypeNamespaceAndName(metadataReader, attributeType, out namespaceString, out nameHandle));
}
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata(
MetadataReader reader,
ConstantStringValueHandle name,
ushort majorVersion,
ushort minorVersion,
ushort buildNumber,
ushort revisionNumber,
ConstantStringValueHandle culture,
ByteCollection publicKeyOrToken,
global::Internal.Metadata.NativeFormat.AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if (0 != (assemblyFlags & global::Internal.Metadata.NativeFormat.AssemblyFlags.PublicKey))
{
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
}
if (0 != (assemblyFlags & global::Internal.Metadata.NativeFormat.AssemblyFlags.Retargetable))
{
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
}
int contentType = ((int)assemblyFlags) & 0x00000E00;
assemblyNameFlags |= (AssemblyNameFlags)contentType;
ArrayBuilder <byte> keyOrTokenArrayBuilder = new ArrayBuilder <byte>();
foreach (byte b in publicKeyOrToken)
{
keyOrTokenArrayBuilder.Add(b);
}
return(new RuntimeAssemblyName(
name.GetString(reader),
new Version(majorVersion, minorVersion, buildNumber, revisionNumber),
culture.GetStringOrNull(reader),
assemblyNameFlags,
keyOrTokenArrayBuilder.ToArray()
));
}
public static string GetString(this ConstantStringValueHandle handle, MetadataReader reader)
{
return(reader.GetConstantStringValue(handle).Value);
}
/// <summary>
/// Emit a string (represented by a serialized ConstantStringValue) to the output string builder.
/// </summary>
/// <param name="stringHandle">Constant string value token (offset within stack trace native metadata)</param>
private void EmitString(ConstantStringValueHandle stringHandle)
{
_outputBuilder.Append(_metadataReader.GetConstantStringValue(stringHandle).Value);
}
internal NamespaceChain(MetadataReader reader, NamespaceDefinitionHandle innerMostNamespaceHandle)
{
NamespaceDefinition currentNamespaceDefinition = innerMostNamespaceHandle.GetNamespaceDefinition(reader);
ConstantStringValueHandle currentNameHandle = currentNamespaceDefinition.Name;
Handle currentNamespaceHandle = innerMostNamespaceHandle.ToHandle(reader);
LowLevelList <String> names = new LowLevelList <String>();
for (;;)
{
String name = currentNameHandle.GetStringOrNull(reader);
names.Add(name);
currentNamespaceHandle = currentNamespaceDefinition.ParentScopeOrNamespace;
HandleType handleType = currentNamespaceHandle.HandleType;
if (handleType == HandleType.ScopeDefinition)
{
break;
}
if (handleType == HandleType.NamespaceDefinition)
{
NamespaceDefinitionHandle nsHandle = currentNamespaceHandle.ToNamespaceDefinitionHandle(reader);
currentNamespaceDefinition = nsHandle.GetNamespaceDefinition(reader);
currentNameHandle = currentNamespaceDefinition.Name;
continue;
}
throw new BadImageFormatException(SR.Bif_InvalidMetadata);
}
DefiningScope = currentNamespaceHandle.ToScopeDefinitionHandle(reader);
int count = names.Count;
if (count == 0)
{
// Every namespace chain has to start with the root namespace.
throw new BadImageFormatException();
}
else if (count == 1)
{
// The root namespace. For compat with the desktop, TypeInfo.NameSpaces returns null in this case.
NameSpace = null;
}
else
{
// Namespace has at least one non-root component.
StringBuilder sb = new StringBuilder();
int idx = count - 1;
while (idx-- != 0)
{
String name = names[idx];
if (name == null)
{
throw new BadImageFormatException(); // null namespace fragment found in middle.
}
sb.Append(name);
if (idx != 0)
{
sb.Append('.');
}
}
NameSpace = sb.ToString();
}
}
public sealed override bool Matches(ConstantStringValueHandle stringHandle, MetadataReader reader) => stringHandle.GetConstantStringValue(reader).Value.Equals(ExpectedName, StringComparison.OrdinalIgnoreCase);
public sealed override bool Matches(ConstantStringValueHandle stringHandle, MetadataReader reader) => stringHandle.StringEquals(ExpectedName, reader);
public abstract bool Matches(ConstantStringValueHandle stringHandle, MetadataReader reader);
public static bool GetAttributeTypeNamespaceAndName(this MetadataReader metadataReader, Handle attributeType,
out string namespaceString, out ConstantStringValueHandle nameHandle)
{
namespaceString = null;
nameHandle = default(ConstantStringValueHandle);
if (attributeType.HandleType == HandleType.TypeReference)
{
TypeReference typeRefRow = metadataReader.GetTypeReference(attributeType.ToTypeReferenceHandle(metadataReader));
HandleType handleType = typeRefRow.ParentNamespaceOrType.HandleType;
// Nested type?
if (handleType == HandleType.TypeReference || handleType == HandleType.TypeDefinition)
{
return(false);
}
nameHandle = typeRefRow.TypeName;
namespaceString = metadataReader.GetNamespaceName(typeRefRow.ParentNamespaceOrType.ToNamespaceReferenceHandle(metadataReader));
return(true);
}
else if (attributeType.HandleType == HandleType.TypeDefinition)
{
var def = metadataReader.GetTypeDefinition(attributeType.ToTypeDefinitionHandle(metadataReader));
// Nested type?
if (IsNested(def.Flags))
{
return(false);
}
nameHandle = def.Name;
namespaceString = metadataReader.GetNamespaceName(def.NamespaceDefinition);
return(true);
}
else
{
// unsupported metadata
return(false);
}
}
