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; }