public sealed override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
binder.EnsureNotCustomBinder();
if (parameters == null)
parameters = Array.Empty<Object>();
Object ctorAllocatedObject = this.MethodInvoker.Invoke(null, parameters);
return ctorAllocatedObject;
}
public sealed override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
ReflectionTrace.MethodBase_Invoke(this, obj, parameters);
#endif
binder.EnsureNotCustomBinder();
if (parameters == null)
parameters = Array.Empty<Object>();
MethodInvoker methodInvoker;
try
{
methodInvoker = this.MethodInvoker;
}
catch (Exception)
{
//
// Project N compat note: On the desktop, ConstructorInfo.Invoke(Object[]) specifically forbids invoking static constructors (and
// for us, that check is embedded inside the MethodInvoker property call.) Howver, MethodBase.Invoke(Object, Object[]) allows it. This was
// probably an oversight on the desktop. We choose not to support this loophole on Project N for the following reasons:
//
// 1. The Project N toolchain aggressively replaces static constructors with static initialization data whenever possible.
// So the static constructor may no longer exist.
//
// 2. Invoking the static constructor through Reflection is not very useful as it invokes the static constructor whether or not
// it was already run. Since static constructors are specifically one-shot deals, this will almost certainly mess up the
// type's internal assumptions.
//
if (this.IsStatic)
throw new PlatformNotSupportedException(SR.Acc_NotClassInit);
throw;
}
return methodInvoker.Invoke(obj, parameters);
}
public sealed override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
ReflectionTrace.FieldInfo_SetValue(this, obj, value);
#endif
binder.EnsureNotCustomBinder();
FieldAccessor fieldAccessor = this.FieldAccessor;
fieldAccessor.SetField(obj, value);
}
public sealed override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
ReflectionTrace.PropertyInfo_SetValue(this, obj, value, index);
#endif
binder.EnsureNotCustomBinder();
if (_lazySetterInvoker == null)
{
if (!CanWrite)
throw new ArgumentException();
_lazySetterInvoker = Setter.GetUncachedMethodInvoker(Array.Empty<RuntimeTypeInfo>(), this);
}
Object[] arguments;
if (index == null)
{
arguments = new Object[] { value };
}
else
{
arguments = new Object[index.Length + 1];
for (int i = 0; i < index.Length; i++)
{
arguments[i] = index[i];
}
arguments[index.Length] = value;
}
_lazySetterInvoker.Invoke(obj, arguments);
}
public sealed override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
ReflectionTrace.PropertyInfo_GetValue(this, obj, index);
#endif
binder.EnsureNotCustomBinder();
if (_lazyGetterInvoker == null)
{
if (!CanRead)
throw new ArgumentException();
_lazyGetterInvoker = Getter.GetUncachedMethodInvoker(Array.Empty<RuntimeTypeInfo>(), this);
}
if (index == null)
index = Array.Empty<Object>();
return _lazyGetterInvoker.Invoke(obj, index);
}
public sealed override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
ReflectionTrace.ConstructorInfo_Invoke(this, parameters);
#endif
binder.EnsureNotCustomBinder();
if (parameters == null)
parameters = Array.Empty<Object>();
// Most objects are allocated by NewObject and their constructors return "void". But in many frameworks,
// there are "weird" cases (e.g. String) where the constructor must do both the allocation and initialization.
// Reflection.Core does not hardcode these special cases. It's up to the ExecutionEnvironment to steer
// us the right way by coordinating the implementation of NewObject and MethodInvoker.
Object newObject = ReflectionCoreExecution.ExecutionEnvironment.NewObject(this.DeclaringType.TypeHandle);
Object ctorAllocatedObject = this.MethodInvoker.Invoke(newObject, parameters);
return newObject != null ? newObject : ctorAllocatedObject;
}
public sealed override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
ReflectionTrace.PropertyInfo_SetValue(this, obj, value, index);
#endif
binder.EnsureNotCustomBinder();
if (_lazySetterInvoker == null)
{
MethodHandle setterMethodHandle;
if (!GetAccessor(MethodSemanticsAttributes.Setter, out setterMethodHandle))
throw new ArgumentException();
MethodAttributes setterMethodAttributes = setterMethodHandle.GetMethod(_reader).Flags;
_lazySetterInvoker = ReflectionCoreExecution.ExecutionEnvironment.GetMethodInvoker(_reader, _contextTypeInfo, setterMethodHandle, Array.Empty<RuntimeTypeInfo>(), this);
}
Object[] arguments;
if (index == null)
{
arguments = new Object[] { value };
}
else
{
arguments = new Object[index.Length + 1];
for (int i = 0; i < index.Length; i++)
{
arguments[i] = index[i];
}
arguments[index.Length] = value;
}
_lazySetterInvoker.Invoke(obj, arguments);
}
public sealed override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
ReflectionTrace.PropertyInfo_GetValue(this, obj, index);
#endif
binder.EnsureNotCustomBinder();
if (_lazyGetterInvoker == null)
{
MethodHandle getterMethodHandle;
if (!GetAccessor(MethodSemanticsAttributes.Getter, out getterMethodHandle))
throw new ArgumentException();
MethodAttributes getterMethodAttributes = getterMethodHandle.GetMethod(_reader).Flags;
_lazyGetterInvoker = ReflectionCoreExecution.ExecutionEnvironment.GetMethodInvoker(_reader, _contextTypeInfo, getterMethodHandle, Array.Empty<RuntimeTypeInfo>(), this);
}
if (index == null)
index = Array.Empty<Object>();
return _lazyGetterInvoker.Invoke(obj, index);
}
public sealed override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
#if ENABLE_REFLECTION_TRACE
if (ReflectionTrace.Enabled)
ReflectionTrace.MethodBase_Invoke(this, obj, parameters);
#endif
binder.EnsureNotCustomBinder();
if (parameters == null)
parameters = Array.Empty<Object>();
MethodInvoker methodInvoker = this.MethodInvoker;
object result = methodInvoker.Invoke(obj, parameters);
System.Diagnostics.DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
return result;
}
