protected abstract ConstructorInfo?GetConstructorImpl(BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[] types, ParameterModifier[]?modifiers);
public sealed override object InvokeMember(string name, BindingFlags invokeAttr, Binder?binder, object?target, object?[]?args, ParameterModifier[]?modifiers, CultureInfo?culture, string[]?namedParameters) => throw new NotSupportedException(SR.NotSupported_SignatureType);
protected sealed override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder?binder, Type?returnType, Type[]?types, ParameterModifier[]?modifiers) => throw new NotSupportedException(SR.NotSupported_SignatureType);
protected override PropertyInfo?GetPropertyImpl(string name, BindingFlags bindingAttr, Binder?binder,
Type?returnType, Type[]?types, ParameterModifier[]?modifiers)
{
throw new NotSupportedException(SR.NotSupported_NonReflectedType);
}
protected abstract override MethodInfo?GetMethodImpl(string name, BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[]?types, ParameterModifier[]?modifiers);
//
// Note: CreateInstance returns null for Nullable<T>, e.g. CreateInstance(typeof(int?)) returns null.
//
public static object?CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicConstructors)] Type type, BindingFlags bindingAttr, Binder?binder, object?[]?args, CultureInfo?culture, object?[]?activationAttributes)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (type is System.Reflection.Emit.TypeBuilder)
{
throw new NotSupportedException(SR.NotSupported_CreateInstanceWithTypeBuilder);
}
// If they didn't specify a lookup, then we will provide the default lookup.
const int LookupMask = 0x000000FF;
if ((bindingAttr & (BindingFlags)LookupMask) == 0)
{
bindingAttr |= ConstructorDefault;
}
if (activationAttributes?.Length > 0)
{
throw new PlatformNotSupportedException(SR.NotSupported_ActivAttr);
}
if (type.UnderlyingSystemType is RuntimeType rt)
{
return(rt.CreateInstanceImpl(bindingAttr, binder, args, culture));
}
throw new ArgumentException(SR.Arg_MustBeType, nameof(type));
}
// Not valid in a ReflectionOnly context public sealed override object Invoke(object?obj, BindingFlags invokeAttr, Binder?binder, object?[]?parameters, CultureInfo?culture) => throw new InvalidOperationException(SR.Arg_ReflectionOnlyInvoke);
public abstract object?InvokeMember(string name, BindingFlags invokeAttr, Binder?binder, object?target, object[]?args, ParameterModifier[]?modifiers, CultureInfo?culture, string[]?namedParameters);
protected override MethodInfo?GetMethodImpl(string name, BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[]?types, ParameterModifier[]?modifiers)
{
if (global_type_created == null)
{
return(null);
}
if (types == null)
{
return(global_type_created.GetMethod(name));
}
return(global_type_created.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers));
}
protected abstract PropertyInfo?GetPropertyImpl(string name, BindingFlags bindingAttr, Binder?binder, Type?returnType, Type[]?types, ParameterModifier[]?modifiers);
public object?InvokeMember(string name, BindingFlags invokeAttr, Binder?binder, object?target, object[]?args, CultureInfo?culture) => InvokeMember(name, invokeAttr, binder, target, args, null, culture, null);
protected virtual MethodInfo?GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[]?types, ParameterModifier[]?modifiers) => throw new NotSupportedException();
public MethodInfo?GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[] types, ParameterModifier[]?modifiers)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (genericParameterCount < 0)
{
throw new ArgumentException(SR.ArgumentOutOfRange_NeedNonNegNum, nameof(genericParameterCount));
}
if (types == null)
{
throw new ArgumentNullException(nameof(types));
}
for (int i = 0; i < types.Length; i++)
{
if (types[i] == null)
{
throw new ArgumentNullException(nameof(types));
}
}
return(GetMethodImpl(name, genericParameterCount, bindingAttr, binder, callConvention, types, modifiers));
}
public MethodInfo?GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder?binder, Type[] types, ParameterModifier[]?modifiers) => GetMethod(name, genericParameterCount, bindingAttr, binder, CallingConventions.Any, types, modifiers);
public sealed override object?InvokeMember(string name, BindingFlags invokeAttr, Binder?binder, object?target, object?[]?args, ParameterModifier[]?modifiers, CultureInfo?culture, string[]?namedParameters) => throw new InvalidOperationException(SR.Arg_ReflectionOnlyInvoke);
public override void SetValue(object?obj, object?value, BindingFlags invokeAttr, Binder?binder, CultureInfo?culture) => m_field.SetValue(obj, value, invokeAttr, binder, culture);
// Backdoor for RoModule to invoke GetMethodImpl();
internal MethodInfo?InternalGetMethodImpl(string name, BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[]?types, ParameterModifier[]?modifiers)
{
return(GetMethodImpl(name, bindingAttr, binder, callConvention, types, modifiers));
}
public override object?InvokeMember(string name, BindingFlags invokeAttr, Binder?binder, object?target,
object[]?args, ParameterModifier[]?modifiers, CultureInfo?culture, string[]?namedParameters)
{
return(typeImpl.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters));
}
public static ObjectHandle?CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder?binder, object?[]?args, CultureInfo?culture, object?[]?activationAttributes)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(CreateInstanceInternal(assemblyName,
typeName,
ignoreCase,
bindingAttr,
binder,
args,
culture,
activationAttributes,
ref stackMark));
}
protected override ConstructorInfo?GetConstructorImpl(BindingFlags bindingAttr, Binder?binder,
CallingConventions callConvention, Type[] types, ParameterModifier[]?modifiers)
{
return(typeImpl.GetConstructor(bindingAttr, binder, callConvention, types, modifiers));
}
protected override MethodInfo?GetMethodImpl(string name, BindingFlags bindingAttr, Binder?binder,
CallingConventions callConvention, Type[]?types, ParameterModifier[]?modifiers)
{
throw new NotSupportedException(SR.NotSupported_NonReflectedType);
}
protected override MethodInfo?GetMethodImpl(string name, BindingFlags bindingAttr, Binder?binder,
CallingConventions callConvention, Type[]?types, ParameterModifier[]?modifiers)
{
// This is interesting there are two paths into the impl. One that validates
// type as non-null and one where type may be null.
if (types == null)
{
return(typeImpl.GetMethod(name, bindingAttr));
}
else
{
return(typeImpl.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers));
}
}
public override object Invoke(object?obj, BindingFlags invokeAttr, Binder?binder, object?[]?parameters, CultureInfo?culture)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
protected override PropertyInfo?GetPropertyImpl(string name, BindingFlags bindingAttr, Binder?binder,
Type?returnType, Type[]?types, ParameterModifier[]?modifiers)
{
if (returnType == null && types == null)
{
return(typeImpl.GetProperty(name, bindingAttr));
}
else
{
return(typeImpl.GetProperty(name, bindingAttr, binder, returnType, types !, modifiers));
}
}
public override void SetValue(object?obj, object?val, BindingFlags invokeAttr, Binder?binder, CultureInfo?culture)
{
// NOTE!! If this is implemented, make sure that this throws
// a NotSupportedException for Save-only dynamic assemblies.
// Otherwise, it could cause the .cctor to be executed.
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
protected virtual MethodInfo?GetMethodImpl(string name, BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[]?types, ParameterModifier[]?modifiers)
{
throw NotImplemented.ByDesign;
}
protected sealed override MethodInfo GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[]?types, ParameterModifier[]?modifiers) => throw new NotSupportedException(SR.NotSupported_SignatureType);
public override void SetValue(object?obj, object?val, BindingFlags invokeAttr, Binder?binder, CultureInfo?culture)
{
throw CreateNotSupportedException();
}
protected sealed override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder?binder, CallingConventions callConvention, Type[] types, ParameterModifier[]?modifiers) => throw new NotSupportedException(SR.NotSupported_SignatureType);
public ConstructorInfo?GetConstructor(BindingFlags bindingAttr, Binder?binder, Type[] types, ParameterModifier[]?modifiers) => GetConstructor(bindingAttr, binder, CallingConventions.Any, types, modifiers);
