public override void SetValue(object obj, object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture) { if (!IsStatic) { if (obj == null) { throw new TargetException("Non-static field requires a target"); } if (!DeclaringType.IsAssignableFrom(obj.GetType())) { throw new ArgumentException(string.Format( "Field {0} defined on type {1} is not a field on the target object which is of type {2}.", Name, DeclaringType, obj.GetType()), "obj"); } } if (IsLiteral) { throw new FieldAccessException("Cannot set a constant field"); } if (binder == null) { binder = Type.DefaultBinder; } CheckGeneric(); if (val != null) { RuntimeType fieldType = (RuntimeType)FieldType; val = fieldType.CheckValue(val, binder, culture, invokeAttr); } SetValueInternal(this, obj, val); }
public override void SetValue(object?obj, object?value, BindingFlags invokeAttr, Binder?binder, CultureInfo?culture) { INVOCATION_FLAGS invocationFlags = InvocationFlags; RuntimeType? declaringType = DeclaringType as RuntimeType; if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != 0) { if (declaringType != null && declaringType.ContainsGenericParameters) { throw new InvalidOperationException(SR.Arg_UnboundGenField); } throw new FieldAccessException(); } CheckConsistency(obj); RuntimeType fieldType = (RuntimeType)FieldType; value = fieldType.CheckValue(value, binder, culture, invokeAttr); bool domainInitialized = false; if (declaringType == null) { RuntimeFieldHandle.SetValue(this, obj, value, fieldType, m_fieldAttributes, null, ref domainInitialized); } else { domainInitialized = declaringType.DomainInitialized; RuntimeFieldHandle.SetValue(this, obj, value, fieldType, m_fieldAttributes, declaringType, ref domainInitialized); declaringType.DomainInitialized = domainInitialized; } }
internal void InternalSetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture, ref StackCrawlMark stackMark) { INVOCATION_FLAGS invocationFlags = InvocationFlags; RuntimeType declaringType = DeclaringType as RuntimeType; if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != 0) { if (declaringType != null && declaringType.ContainsGenericParameters) throw new InvalidOperationException(SR.Arg_UnboundGenField); if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType) throw new InvalidOperationException(SR.Arg_ReflectionOnlyField); throw new FieldAccessException(); } CheckConsistency(obj); RuntimeType fieldType = (RuntimeType)FieldType; value = fieldType.CheckValue(value, binder, culture, invokeAttr); bool domainInitialized = false; if (declaringType == null) { RuntimeFieldHandle.SetValue(this, obj, value, fieldType, m_fieldAttributes, null, ref domainInitialized); } else { domainInitialized = declaringType.DomainInitialized; RuntimeFieldHandle.SetValue(this, obj, value, fieldType, m_fieldAttributes, declaringType, ref domainInitialized); declaringType.DomainInitialized = domainInitialized; } }
internal Object[] CheckArguments(Object[] parameters, Binder binder, BindingFlags invokeAttr, CultureInfo culture, Signature sig) { // copy the arguments in a different array so we detach from any user changes Object[] copyOfParameters = new Object[parameters.Length]; ParameterInfo[] p = null; for (int i = 0; i < parameters.Length; i++) { Object arg = parameters[i]; RuntimeType argRT = sig.Arguments[i]; if (arg == Type.Missing) { if (p == null) { p = GetParametersNoCopy(); } if (p[i].DefaultValue == System.DBNull.Value) { throw new ArgumentException(Environment.GetResourceString("Arg_VarMissNull"), "parameters"); } arg = p[i].DefaultValue; } copyOfParameters[i] = argRT.CheckValue(arg, binder, culture, invokeAttr); } return(copyOfParameters); }
internal object[] CheckArguments(object[] parameters, Binder?binder, BindingFlags invokeAttr, CultureInfo?culture, Signature sig) { // copy the arguments in a different array so we detach from any user changes object[] copyOfParameters = new object[parameters.Length]; ParameterInfo[]? p = null; for (int i = 0; i < parameters.Length; i++) { object arg = parameters[i]; RuntimeType argRT = sig.Arguments[i]; if (arg == Type.Missing) { p ??= GetParametersNoCopy(); if (p[i].DefaultValue == System.DBNull.Value) { throw new ArgumentException(SR.Arg_VarMissNull, nameof(parameters)); } arg = p[i].DefaultValue !; } copyOfParameters[i] = argRT.CheckValue(arg, binder, culture, invokeAttr) !; } return(copyOfParameters); }
internal object[] CheckArguments(object[] parameters, Binder binder, BindingFlags invokeAttr, CultureInfo culture, Signature sig) { int num = (parameters != null) ? parameters.Length : 0; object[] objArray = new object[num]; ParameterInfo[] parametersNoCopy = null; for (int i = 0; i < num; i++) { object defaultValue = parameters[i]; RuntimeType type = sig.Arguments[i]; if (defaultValue == Type.Missing) { if (parametersNoCopy == null) { parametersNoCopy = this.GetParametersNoCopy(); } if (parametersNoCopy[i].DefaultValue == DBNull.Value) { throw new ArgumentException(Environment.GetResourceString("Arg_VarMissNull"), "parameters"); } defaultValue = parametersNoCopy[i].DefaultValue; } objArray[i] = type.CheckValue(defaultValue, binder, culture, invokeAttr); } return(objArray); }
internal void InternalSetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture, ref StackCrawlMark stackMark) { INVOCATION_FLAGS invocationFlags = InvocationFlags; RuntimeType declaringType = DeclaringType as RuntimeType; if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != 0) { if (declaringType != null && declaringType.ContainsGenericParameters) { throw new InvalidOperationException(Environment.GetResourceString("Arg_UnboundGenField")); } if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType) { throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyField")); } throw new FieldAccessException(); } CheckConsistency(obj); RuntimeType fieldType = (RuntimeType)FieldType; value = fieldType.CheckValue(value, binder, culture, invokeAttr); #region Security Check #if FEATURE_APPX if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NON_W8P_FX_API) != 0) { RuntimeAssembly caller = RuntimeAssembly.GetExecutingAssembly(ref stackMark); if (caller != null && !caller.IsSafeForReflection()) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_APIInvalidForCurrentContext", FullName)); } } #endif if ((invocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_SPECIAL_FIELD | INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY)) != 0) { PerformVisibilityCheckOnField(m_fieldHandle, obj, m_declaringType, m_fieldAttributes, (uint)m_invocationFlags); } #endregion bool domainInitialized = false; if (declaringType == null) { RuntimeFieldHandle.SetValue(this, obj, value, fieldType, m_fieldAttributes, null, ref domainInitialized); } else { domainInitialized = declaringType.DomainInitialized; RuntimeFieldHandle.SetValue(this, obj, value, fieldType, m_fieldAttributes, declaringType, ref domainInitialized); declaringType.DomainInitialized = domainInitialized; } }
private protected Span <object?> CheckArguments( ref StackAllocedArguments stackArgs, object?[]?parameters, Binder?binder, BindingFlags invokeAttr, CultureInfo?culture, Signature sig ) { Debug.Assert( Unsafe.SizeOf <StackAllocedArguments>() == StackAllocedArguments.MaxStackAllocArgCount * Unsafe.SizeOf <object>(), "MaxStackAllocArgCount not properly defined." ); Span <object?> copyOfParameters = default; if (parameters is not null) { // We need to perform type safety validation against the incoming arguments, but we also need // to be resilient against the possibility that some other thread (or even the binder itself!) // may mutate the array after we've validated the arguments but before we've properly invoked // the method. The solution is to copy the arguments to a different, not-user-visible buffer // as we validate them. n.b. This disallows use of ArrayPool, as ArrayPool-rented arrays are // considered user-visible to threads which may still be holding on to returned instances. copyOfParameters = (parameters.Length <= StackAllocedArguments.MaxStackAllocArgCount) ? MemoryMarshal.CreateSpan(ref stackArgs._arg0, parameters.Length) : new Span <object?>(new object?[parameters.Length]); ParameterInfo[]? p = null; for (int i = 0; i < parameters.Length; i++) { object? arg = parameters[i]; RuntimeType argRT = sig.Arguments[i]; if (arg == Type.Missing) { p ??= GetParametersNoCopy(); if (p[i].DefaultValue == System.DBNull.Value) { throw new ArgumentException(SR.Arg_VarMissNull, nameof(parameters)); } arg = p[i].DefaultValue !; } copyOfParameters[i] = argRT.CheckValue(arg, binder, culture, invokeAttr); } } return(copyOfParameters); }
internal void InternalSetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture, ref StackCrawlMark stackMark) { INVOCATION_FLAGS invocationFlags = this.InvocationFlags; RuntimeType runtimeType = this.DeclaringType as RuntimeType; if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN) { if (runtimeType != null && runtimeType.ContainsGenericParameters) { throw new InvalidOperationException(Environment.GetResourceString("Arg_UnboundGenField")); } if ((runtimeType == null && this.Module.Assembly.ReflectionOnly) || runtimeType is ReflectionOnlyType) { throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyField")); } throw new FieldAccessException(); } else { this.CheckConsistency(obj); RuntimeType runtimeType2 = (RuntimeType)this.FieldType; value = runtimeType2.CheckValue(value, binder, culture, invokeAttr); if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NON_W8P_FX_API) != INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN) { RuntimeAssembly executingAssembly = RuntimeAssembly.GetExecutingAssembly(ref stackMark); if (executingAssembly != null && !executingAssembly.IsSafeForReflection()) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_APIInvalidForCurrentContext", new object[] { this.FullName })); } } if ((invocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY | INVOCATION_FLAGS.INVOCATION_FLAGS_IS_CTOR)) != INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN) { RtFieldInfo.PerformVisibilityCheckOnField(this.m_fieldHandle, obj, this.m_declaringType, this.m_fieldAttributes, (uint)this.m_invocationFlags); } bool domainInitialized = false; if (runtimeType == null) { RuntimeFieldHandle.SetValue(this, obj, value, runtimeType2, this.m_fieldAttributes, null, ref domainInitialized); return; } domainInitialized = runtimeType.DomainInitialized; RuntimeFieldHandle.SetValue(this, obj, value, runtimeType2, this.m_fieldAttributes, runtimeType, ref domainInitialized); runtimeType.DomainInitialized = domainInitialized; return; } }
internal void UnsafeSetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) { RuntimeType runtimeType = this.DeclaringType as RuntimeType; RuntimeType runtimeType2 = (RuntimeType)this.FieldType; value = runtimeType2.CheckValue(value, binder, culture, invokeAttr); bool domainInitialized = false; if (runtimeType == null) { RuntimeFieldHandle.SetValue(this, obj, value, runtimeType2, this.m_fieldAttributes, null, ref domainInitialized); return; } domainInitialized = runtimeType.DomainInitialized; RuntimeFieldHandle.SetValue(this, obj, value, runtimeType2, this.m_fieldAttributes, runtimeType, ref domainInitialized); runtimeType.DomainInitialized = domainInitialized; }
internal void UnsafeSetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) { RuntimeType declaringType = DeclaringType as RuntimeType; RuntimeType fieldType = (RuntimeType)FieldType; value = fieldType.CheckValue(value, binder, culture, invokeAttr); bool domainInitialized = false; if (declaringType == null) { RuntimeFieldHandle.SetValue(this, obj, value, fieldType, m_fieldAttributes, null, ref domainInitialized); } else { domainInitialized = declaringType.DomainInitialized; RuntimeFieldHandle.SetValue(this, obj, value, fieldType, m_fieldAttributes, declaringType, ref domainInitialized); declaringType.DomainInitialized = domainInitialized; } }
internal void InternalSetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture, bool doVisibilityCheck, bool doCheckConsistency) { INVOCATION_FLAGS invocationFlags = this.InvocationFlags; RuntimeType declaringType = this.DeclaringType as RuntimeType; if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN) { if ((declaringType != null) && declaringType.ContainsGenericParameters) { throw new InvalidOperationException(Environment.GetResourceString("Arg_UnboundGenField")); } if (((declaringType != null) || !this.Module.Assembly.ReflectionOnly) && !(declaringType is ReflectionOnlyType)) { throw new FieldAccessException(); } throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyField")); } if (doCheckConsistency) { this.CheckConsistency(obj); } RuntimeType fieldType = (RuntimeType)this.FieldType; value = fieldType.CheckValue(value, binder, culture, invokeAttr); if (doVisibilityCheck && ((invocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_IS_CTOR | INVOCATION_FLAGS.INVOCATION_FLAGS_NEED_SECURITY)) != INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN)) { PerformVisibilityCheckOnField(this.m_fieldHandle, obj, base.m_declaringType, this.m_fieldAttributes, (uint)this.m_invocationFlags); } bool domainInitialized = false; if (declaringType == null) { RuntimeFieldHandle.SetValue(this, obj, value, fieldType, this.m_fieldAttributes, null, ref domainInitialized); } else { domainInitialized = declaringType.DomainInitialized; RuntimeFieldHandle.SetValue(this, obj, value, fieldType, this.m_fieldAttributes, declaringType, ref domainInitialized); declaringType.DomainInitialized = domainInitialized; } }
public override void SetValue(object?obj, object?val, BindingFlags invokeAttr, Binder?binder, CultureInfo?culture) { if (!IsStatic) { if (obj == null) { throw new TargetException("Non-static field requires a target"); } if (!DeclaringType !.IsAssignableFrom(obj.GetType())) { throw new ArgumentException(string.Format( "Field {0} defined on type {1} is not a field on the target object which is of type {2}.", Name, DeclaringType, obj.GetType()), nameof(obj)); } } if (IsLiteral) { throw new FieldAccessException("Cannot set a constant field"); } if (binder == null) { binder = Type.DefaultBinder; } CheckGeneric(); if (val != null) { RuntimeType fieldType = (RuntimeType)FieldType; ParameterCopyBackAction _ = default; if (!ReferenceEquals(val.GetType(), fieldType)) { fieldType.CheckValue(ref val, ref _, binder, culture, invokeAttr); } } Invoker.SetValue(obj, val); }
internal object[] CheckArguments(object[] parameters, Binder binder, BindingFlags invokeAttr, CultureInfo culture, Signature sig) { object[] objArray = new object[parameters.Length]; ParameterInfo[] parameterInfoArray = (ParameterInfo[])null; for (int index = 0; index < parameters.Length; ++index) { object obj = parameters[index]; RuntimeType runtimeType = sig.Arguments[index]; if (obj == Type.Missing) { if (parameterInfoArray == null) { parameterInfoArray = this.GetParametersNoCopy(); } if (parameterInfoArray[index].DefaultValue == DBNull.Value) { throw new ArgumentException(Environment.GetResourceString("Arg_VarMissNull"), "parameters"); } obj = parameterInfoArray[index].DefaultValue; } objArray[index] = runtimeType.CheckValue(obj, binder, culture, invokeAttr); } return(objArray); }
private protected unsafe void CheckArguments( Span <object?> copyOfParameters, IntPtr *byrefParameters, Span <ParameterCopyBackAction> shouldCopyBack, ReadOnlySpan <object?> parameters, RuntimeType[] sigTypes, Binder?binder, CultureInfo?culture, BindingFlags invokeAttr ) { Debug.Assert(parameters.Length > 0); ParameterInfo[]? paramInfos = null; for (int i = 0; i < parameters.Length; i++) { ParameterCopyBackAction copyBackArg = default; bool isValueType = false; object? arg = parameters[i]; RuntimeType sigType = sigTypes[i]; // Convert a Type.Missing to the default value. if (ReferenceEquals(arg, Type.Missing)) { paramInfos ??= GetParametersNoCopy(); ParameterInfo paramInfo = paramInfos[i]; if (paramInfo.DefaultValue == DBNull.Value) { throw new ArgumentException(SR.Arg_VarMissNull, nameof(parameters)); } arg = paramInfo.DefaultValue; if (sigType.IsNullableOfT) { copyBackArg = ParameterCopyBackAction.CopyNullable; if (arg is not null) { // For nullable Enum types, the ParameterInfo.DefaultValue returns a raw value which // needs to be parsed to the Enum type, for more info: https://github.com/dotnet/runtime/issues/12924 Type argumentType = sigType.GetGenericArguments()[0]; if (argumentType.IsEnum) { arg = Enum.ToObject(argumentType, arg); } } } else { copyBackArg = ParameterCopyBackAction.Copy; } } if (arg is null) { // Fast path for null reference types. isValueType = RuntimeTypeHandle.IsValueType(sigType); if (isValueType || RuntimeTypeHandle.IsByRef(sigType)) { isValueType = sigType.CheckValue(ref arg, ref copyBackArg, binder, culture, invokeAttr); } } else { RuntimeType argType = (RuntimeType)arg.GetType(); if (ReferenceEquals(argType, sigType)) { // Fast path when the value's type matches the signature type. isValueType = RuntimeTypeHandle.IsValueType(argType); } else if (sigType.TryByRefFastPath(ref arg, ref isValueType)) { // Fast path when the value's type matches the signature type of a byref parameter. copyBackArg = ParameterCopyBackAction.Copy; } else { // Slow path that supports type conversions. isValueType = sigType.CheckValue(ref arg, ref copyBackArg, binder, culture, invokeAttr); } } // We need to perform type safety validation against the incoming arguments, but we also need // to be resilient against the possibility that some other thread (or even the binder itself!) // may mutate the array after we've validated the arguments but before we've properly invoked // the method. The solution is to copy the arguments to a different, not-user-visible buffer // as we validate them. n.b. This disallows use of ArrayPool, as ArrayPool-rented arrays are // considered user-visible to threads which may still be holding on to returned instances. // This separate array is also used to hold default values when 'null' is specified for value // types, and also used to hold the results from conversions such as from Int16 to Int32. For // compat, these default values and conversions are not be applied to the incoming arguments. shouldCopyBack[i] = copyBackArg; copyOfParameters[i] = arg; if (isValueType) { #if !MONO // Temporary until Mono is updated. Debug.Assert(arg != null); Debug.Assert( arg.GetType() == sigType || (sigType.IsPointer && (arg.GetType() == typeof(IntPtr) || arg.GetType() == typeof(UIntPtr))) || (sigType.IsByRef && arg.GetType() == RuntimeTypeHandle.GetElementType(sigType)) || ((sigType.IsEnum || arg.GetType().IsEnum) && RuntimeType.GetUnderlyingType((RuntimeType)arg.GetType()) == RuntimeType.GetUnderlyingType(sigType))); #endif ByReference valueTypeRef = ByReference.Create(ref copyOfParameters[i] !.GetRawData()); *(ByReference *)(byrefParameters + i) = valueTypeRef; } else { ByReference objRef = ByReference.Create(ref copyOfParameters[i]); *(ByReference *)(byrefParameters + i) = objRef; } } }
private protected unsafe void CheckArguments( Span <object?> copyOfParameters, IntPtr *byrefParameters, Span <bool> shouldCopyBack, ReadOnlySpan <object?> parameters, RuntimeType[] sigTypes, Binder?binder, CultureInfo?culture, BindingFlags invokeAttr ) { Debug.Assert(!parameters.IsEmpty); ParameterInfo[]? paramInfos = null; for (int i = 0; i < parameters.Length; i++) { bool copyBackArg = false; bool isValueType; object? arg = parameters[i]; RuntimeType sigType = sigTypes[i]; if (arg is null) { // Fast path that avoids calling CheckValue() for reference types. isValueType = RuntimeTypeHandle.IsValueType(sigType); if (isValueType || RuntimeTypeHandle.IsByRef(sigType)) { isValueType = sigType.CheckValue(ref arg, ref copyBackArg, binder, culture, invokeAttr); } } else if (ReferenceEquals(arg.GetType(), sigType)) { // Fast path that avoids calling CheckValue() when argument value matches the signature type. isValueType = RuntimeTypeHandle.IsValueType(sigType); } else { paramInfos ??= GetParametersNoCopy(); ParameterInfo paramInfo = paramInfos[i]; if (!ReferenceEquals(arg, Type.Missing)) { isValueType = sigType.CheckValue(ref arg, ref copyBackArg, binder, culture, invokeAttr); } else { if (paramInfo.DefaultValue == DBNull.Value) { throw new ArgumentException(SR.Arg_VarMissNull, nameof(parameters)); } arg = paramInfo.DefaultValue; if (ReferenceEquals(arg?.GetType(), sigType)) { isValueType = RuntimeTypeHandle.IsValueType(sigType); } else { isValueType = sigType.CheckValue(ref arg, ref copyBackArg, binder, culture, invokeAttr); } } } // We need to perform type safety validation against the incoming arguments, but we also need // to be resilient against the possibility that some other thread (or even the binder itself!) // may mutate the array after we've validated the arguments but before we've properly invoked // the method. The solution is to copy the arguments to a different, not-user-visible buffer // as we validate them. n.b. This disallows use of ArrayPool, as ArrayPool-rented arrays are // considered user-visible to threads which may still be holding on to returned instances. // This separate array is also used to hold default values when 'null' is specified for value // types, and also used to hold the results from conversions such as from Int16 to Int32; these // default values and conversions should not be applied to the incoming arguments. shouldCopyBack[i] = copyBackArg; copyOfParameters[i] = arg; if (isValueType) { #if DEBUG // Once Mono has managed conversion logic, VerifyValueType() can be lifted here as Asserts. sigType.VerifyValueType(arg); #endif ByReference <byte> valueTypeRef = new(ref copyOfParameters[i] !.GetRawData()); *(ByReference <byte> *)(byrefParameters + i) = valueTypeRef; } else { ByReference <object?> objRef = new(ref copyOfParameters[i]); *(ByReference <object?> *)(byrefParameters + i) = objRef; } } }