//
// If throwIfMissingMetadata is false, returns null rather than throwing a MissingMetadataException.
//
internal sealed override IList <CustomAttributeNamedArgument> GetNamedArguments(bool throwIfMissingMetadata)
{
LowLevelListWithIList <CustomAttributeNamedArgument> customAttributeNamedArguments = new LowLevelListWithIList <CustomAttributeNamedArgument>();
foreach (NamedArgumentHandle namedArgumentHandle in _customAttribute.NamedArguments)
{
NamedArgument namedArgument = namedArgumentHandle.GetNamedArgument(_reader);
String memberName = namedArgument.Name.GetString(_reader);
bool isField = (namedArgument.Flags == NamedArgumentMemberKind.Field);
CustomAttributeTypedArgument typedValue =
ParseFixedArgument(
_reader,
namedArgument.Value,
throwIfMissingMetadata,
delegate()
{
// We got here because the custom attribute blob did not inclue type information. For named arguments, this is considered illegal metadata
// (ECMA always includes type info for named arguments.)
throw new BadImageFormatException();
}
);
if (typedValue.ArgumentType == null)
{
Debug.Assert(!throwIfMissingMetadata);
return(null);
}
customAttributeNamedArguments.Add(ReflectionAugments.CreateCustomAttributeNamedArgument(this.AttributeType, memberName, isField, typedValue));
}
return(customAttributeNamedArguments);
}
//
// One time initialization to supply the information needed to initialize the execution environment.
//
public static void InitializeExecutionDomain(ReflectionDomainSetup executionDomainSetup, ExecutionEnvironment executionEnvironment)
{
ExecutionDomain executionDomain = new ExecutionDomain(executionDomainSetup, executionEnvironment);
//@todo: This check has a race window but since this is a private api targeted by the toolchain, perhaps this is not so critical.
if (s_executionDomain != null)
{
throw new InvalidOperationException(); // Multiple Initializes not allowed.
}
s_executionDomain = executionDomain;
ReflectionCoreCallbacks reflectionCallbacks = new ReflectionCoreCallbacksImplementation();
ReflectionAugments.Initialize(reflectionCallbacks);
return;
}
// 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;
}
protected sealed override TypeCode GetTypeCodeImpl()
{
return(ReflectionAugments.GetRuntimeTypeCode(this));
}
public static TypeLoadException CreateTypeLoadException(string typeName, string assemblyName)
{
string message = SR.Format(SR.TypeLoad_TypeNotFoundInAssembly, typeName, assemblyName);
return(ReflectionAugments.CreateTypeLoadException(message, typeName));
}
public sealed override Type MakeGenericType(params Type[] typeArguments)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
{
ReflectionTrace.TypeInfo_MakeGenericType(this, typeArguments);
}
#endif
if (typeArguments == null)
{
throw new ArgumentNullException(nameof(typeArguments));
}
if (!IsGenericTypeDefinition)
{
throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericTypeDefinition, this));
}
// We intentionally don't validate the number of arguments or their suitability to the generic type's constraints.
// In a pay-for-play world, this can cause needless MissingMetadataExceptions. There is no harm in creating
// the Type object for an inconsistent generic type - no EEType will ever match it so any attempt to "invoke" it
// will throw an exception.
bool foundSignatureType = false;
RuntimeTypeInfo[] runtimeTypeArguments = new RuntimeTypeInfo[typeArguments.Length];
for (int i = 0; i < typeArguments.Length; i++)
{
RuntimeTypeInfo runtimeTypeArgument = runtimeTypeArguments[i] = typeArguments[i] as RuntimeTypeInfo;
if (runtimeTypeArgument == null)
{
if (typeArguments[i] == null)
{
throw new ArgumentNullException();
}
if (typeArguments[i].IsSignatureType)
{
foundSignatureType = true;
}
else
{
throw new PlatformNotSupportedException(SR.PlatformNotSupported_MakeGenericType); // "PlatformNotSupported" because on desktop, passing in a foreign type is allowed and creates a RefEmit.TypeBuilder
}
}
}
if (foundSignatureType)
{
return(ReflectionAugments.MakeGenericSignatureType(this, typeArguments));
}
for (int i = 0; i < typeArguments.Length; i++)
{
RuntimeTypeInfo runtimeTypeArgument = runtimeTypeArguments[i];
// Desktop compatibility: Treat generic type definitions as a constructed generic type using the generic parameters as type arguments.
if (runtimeTypeArgument.IsGenericTypeDefinition)
{
runtimeTypeArgument = runtimeTypeArguments[i] = runtimeTypeArgument.GetConstructedGenericType(runtimeTypeArgument.RuntimeGenericTypeParameters);
}
if (runtimeTypeArgument.IsByRefLike)
{
throw new TypeLoadException(SR.CannotUseByRefLikeTypeInInstantiation);
}
}
return(this.GetConstructedGenericType(runtimeTypeArguments));
}
public static void InitializeLibrary()
{
RuntimeAugments.Initialize(new ReflectionExecutionDomainCallbacksImplementation());
ReflectionAugments.Initialize(new ReflectionCoreCallbacksImplementation());
}
