public sealed override String ToString()
{
try
{
TypeContext typeContext = _contextTypeInfo.TypeContext;
ReflectionTypeProvider reflectionTypeProvider = new ReflectionTypeProvider(throwOnError: false);
RuntimeTypeInfo fieldType = _field.DecodeSignature(reflectionTypeProvider, typeContext);
string fieldTypeName;
if (reflectionTypeProvider.ExceptionOccurred)
{
fieldTypeName = Type.DefaultTypeNameWhenMissingMetadata;
}
else
{
fieldTypeName = fieldType.FormatTypeNameForReflection();
}
return(fieldTypeName + " " + this.Name);
}
catch
{
return(Type.DefaultTypeNameWhenMissingMetadata + " " + this.Name);
}
}
public sealed override String ToString()
{
try
{
TypeContext typeContext = _contextTypeInfo.TypeContext;
ReflectionTypeProvider reflectionTypeProvider = new ReflectionTypeProvider(throwOnError: false);
RuntimeTypeInfo fieldType = _field.DecodeSignature(reflectionTypeProvider, typeContext);
string fieldTypeName;
if (reflectionTypeProvider.ExceptionOccurred)
{
fieldTypeName = ToStringUtils.UnavailableType;
}
else
{
fieldTypeName = fieldType.FormatTypeName();
}
return(fieldTypeName + " " + this.Name);
}
catch
{
return(ToStringUtils.UnavailableType + " " + this.Name);
}
}
//
// Main routine to parse a metadata type specification signature.
//
private static RuntimeTypeInfo TryResolveTypeSignature(this TypeSpecificationHandle typeSpecHandle, MetadataReader reader, TypeContext typeContext, ref Exception exception)
{
TypeSpecification typeSpec = reader.GetTypeSpecification(typeSpecHandle);
ReflectionTypeProvider refTypeProvider = new ReflectionTypeProvider(throwOnError: false);
RuntimeTypeInfo result = typeSpec.DecodeSignature <RuntimeTypeInfo, TypeContext>(refTypeProvider, typeContext);
exception = refTypeProvider.ExceptionResult;
return(result);
}
private RuntimeTypeInfo TryResolveSignature(TypeContext typeContext, ref Exception exception)
{
ReflectionTypeProvider typeProvider = new ReflectionTypeProvider(throwOnError: false);
SignatureDecoder<RuntimeTypeInfo, TypeContext> signatureDecoder = new SignatureDecoder<RuntimeTypeInfo, TypeContext>(typeProvider, (MetadataReader)Reader, typeContext);
BlobReader localCopyOfReader = _blobReader;
RuntimeTypeInfo result = signatureDecoder.DecodeType(ref localCopyOfReader, false);
exception = typeProvider.ExceptionResult;
return result;
}
protected sealed override Guid?ComputeGuidFromCustomAttributes()
{
//
// Look for a [Guid] attribute. If found, return that.
//
foreach (CustomAttributeHandle cah in _typeDefinition.GetCustomAttributes())
{
// We can't reference the GuidAttribute class directly as we don't have an official dependency on System.Runtime.InteropServices.
// Following age-old CLR tradition, we search for the custom attribute using a name-based search. Since this makes it harder
// to be sure we won't run into custom attribute constructors that comply with the GuidAttribute(String) signature,
// we'll check that it does and silently skip the CA if it doesn't match the expected pattern.
CustomAttribute attribute = Reader.GetCustomAttribute(cah);
EntityHandle ctorType;
EcmaMetadataHelpers.GetAttributeTypeDefRefOrSpecHandle(_reader, attribute.Constructor, out ctorType);
StringHandle typeNameHandle;
StringHandle typeNamespaceHandle;
if (EcmaMetadataHelpers.GetAttributeNamespaceAndName(Reader, ctorType, out typeNamespaceHandle, out typeNameHandle))
{
MetadataStringComparer stringComparer = Reader.StringComparer;
if (stringComparer.Equals(typeNamespaceHandle, "System.Runtime.InteropServices"))
{
if (stringComparer.Equals(typeNameHandle, "GuidAttribute"))
{
ReflectionTypeProvider typeProvider = new ReflectionTypeProvider(throwOnError: false);
CustomAttributeValue <RuntimeTypeInfo> customAttributeValue = attribute.DecodeValue(typeProvider);
if (customAttributeValue.FixedArguments.Length != 1)
{
continue;
}
CustomAttributeTypedArgument <RuntimeTypeInfo> firstArg = customAttributeValue.FixedArguments[0];
if (firstArg.Value == null)
{
continue;
}
string guidString = firstArg.Value as string;
if (guidString == null)
{
continue;
}
return(new Guid(guidString));
}
}
}
}
return(null);
}
// Equals/GetHashCode no need to override (they just implement reference equality but desktop never unified these things.)
private void LoadArgumentInfo(bool throwIfMissingMetadata, out IList <CustomAttributeNamedArgument> namedArguments, out IList <CustomAttributeTypedArgument> fixedArguments, out bool metadataWasMissing)
{
LowLevelListWithIList <CustomAttributeNamedArgument> newNamedArguments = new LowLevelListWithIList <CustomAttributeNamedArgument>();
LowLevelListWithIList <CustomAttributeTypedArgument> newFixedArguments = new LowLevelListWithIList <CustomAttributeTypedArgument>();
ReflectionTypeProvider typeProvider = new ReflectionTypeProvider(throwIfMissingMetadata);
CustomAttributeValue <RuntimeTypeInfo> customAttributeValue = _customAttribute.DecodeValue(typeProvider);
foreach (CustomAttributeTypedArgument <RuntimeTypeInfo> fixedArgument in customAttributeValue.FixedArguments)
{
newFixedArguments.Add(WrapInCustomAttributeTypedArgument(fixedArgument.Value, fixedArgument.Type));
}
foreach (CustomAttributeNamedArgument <RuntimeTypeInfo> ecmaNamedArgument in customAttributeValue.NamedArguments)
{
bool isField = ecmaNamedArgument.Kind == CustomAttributeNamedArgumentKind.Field;
CustomAttributeTypedArgument typedArgument = WrapInCustomAttributeTypedArgument(ecmaNamedArgument.Value, ecmaNamedArgument.Type);
newNamedArguments.Add(ReflectionAugments.CreateCustomAttributeNamedArgument(this.AttributeType, ecmaNamedArgument.Name, isField, typedArgument));
}
if (newFixedArguments.Count == 0)
{
fixedArguments = Array.Empty <CustomAttributeTypedArgument>();
}
else
{
fixedArguments = newFixedArguments;
}
if (newNamedArguments.Count == 0)
{
namedArguments = Array.Empty <CustomAttributeNamedArgument>();
}
else
{
namedArguments = newNamedArguments;
}
metadataWasMissing = typeProvider.ExceptionOccurred;
}
