public sealed override Object Invoke(Object thisObject, Object[] arguments)
{
switch (_id)
{
case StringConstructorId.CharArray:
{
CheckArgumentCount(arguments, 1);
char[] value = (char[])(RuntimeAugments.CheckArgument(arguments[0], typeof(char[]).TypeHandle));
return(new String(value));
}
case StringConstructorId.Char_Int:
{
CheckArgumentCount(arguments, 2);
char c = (char)(RuntimeAugments.CheckArgument(arguments[0], typeof(char).TypeHandle));
int count = (int)(RuntimeAugments.CheckArgument(arguments[1], typeof(int).TypeHandle));
return(new String(c, count));
}
case StringConstructorId.CharArray_Int_Int:
{
CheckArgumentCount(arguments, 3);
char[] value = (char[])(RuntimeAugments.CheckArgument(arguments[0], typeof(char[]).TypeHandle));
int startIndex = (int)(RuntimeAugments.CheckArgument(arguments[1], typeof(int).TypeHandle));
int length = (int)(RuntimeAugments.CheckArgument(arguments[2], typeof(int).TypeHandle));
return(new String(value, startIndex, length));
}
default:
throw new InvalidOperationException();
}
}
protected sealed override object?Invoke(object?thisObject, object?[] arguments, BinderBundle binderBundle, bool wrapInTargetInvocationException)
{
Debug.Assert(arguments != null);
// This does not handle optional parameters. None of the methods we use custom invocation for have them.
if (!(thisObject == null && 0 != (_options & InvokerOptions.AllowNullThis)))
{
ValidateThis(thisObject, _thisType.TypeHandle);
}
if (arguments.Length != _parameterTypes.Length)
{
throw new TargetParameterCountException();
}
object[] convertedArguments = new object[arguments.Length];
for (int i = 0; i < arguments.Length; i++)
{
convertedArguments[i] = RuntimeAugments.CheckArgument(arguments[i], _parameterTypes[i].TypeHandle, binderBundle);
}
object result;
try
{
result = _action(thisObject, convertedArguments, _thisType);
}
catch (Exception e) when(wrapInTargetInvocationException)
{
throw new TargetInvocationException(e);
}
return(result);
}
protected sealed override void SetFieldBypassCctor(Object obj, Object value)
{
value = RuntimeAugments.CheckArgument(value, FieldTypeHandle);
IntPtr fieldAddress = RuntimeAugments.GetThreadStaticFieldAddress(_declaringTypeHandle, _cookie);
RuntimeAugments.StoreValueTypeField(fieldAddress, value, FieldTypeHandle);
}
protected sealed override void SetFieldBypassCctor(Object obj, Object value, BinderBundle binderBundle)
{
value = RuntimeAugments.CheckArgument(value, FieldTypeHandle, binderBundle);
IntPtr tlsFieldsStartAddress = RuntimeAugments.GetThreadStaticFieldAddress(_declaringTypeHandle, IntPtr.Zero);
IntPtr fieldAddress = tlsFieldsStartAddress + _fieldOffset;
RuntimeAugments.StoreReferenceTypeField(fieldAddress, value);
}
protected sealed override void SetFieldBypassCctor(object value, BinderBundle binderBundle)
{
value = RuntimeAugments.CheckArgument(value, FieldTypeHandle, binderBundle);
if (IsFieldInitOnly)
{
throw new FieldAccessException(SR.Acc_InitOnlyStatic);
}
UncheckedSetFieldBypassCctor(value);
}
public sealed override void SetField(Object obj, Object value, BinderBundle binderBundle)
{
if (obj == null)
{
throw new TargetException(SR.RFLCT_Targ_StatFldReqTarg);
}
if (!RuntimeAugments.IsAssignable(obj, this.DeclaringTypeHandle))
{
throw new ArgumentException();
}
value = RuntimeAugments.CheckArgument(value, this.FieldTypeHandle, binderBundle);
UncheckedSetField(obj, value);
}
public override Object Invoke(Object thisObject, Object[] arguments, BinderBundle binderBundle)
{
//@todo: This does not handle optional parameters (nor does it need to as today we're only using it for three synthetic array methods.)
if (!(thisObject == null && 0 != (_options & InvokerOptions.AllowNullThis)))
{
MethodInvokerUtils.ValidateThis(thisObject, _thisType);
}
if (arguments == null)
{
arguments = Array.Empty <Object>();
}
if (arguments.Length != _parameterTypes.Length)
{
throw new TargetParameterCountException();
}
Object[] convertedArguments = new Object[arguments.Length];
for (int i = 0; i < arguments.Length; i++)
{
convertedArguments[i] = RuntimeAugments.CheckArgument(arguments[i], _parameterTypes[i], binderBundle);
}
Object result;
try
{
result = _invoker(thisObject, convertedArguments);
}
catch (Exception e)
{
if (0 != (_options & InvokerOptions.DontWrapException))
{
throw;
}
else
{
throw new TargetInvocationException(e);
}
}
return(result);
}
public sealed override Object Invoke(Object thisObject, Object[] arguments)
{
Object value = thisObject;
bool hasValue = (thisObject != null);
switch (_id)
{
case NullableMethodId.GetType:
CheckArgumentCount(arguments, 0);
return(value.GetType()); // Note: this throws a NullReferenceException if hasValue is false. Well so does the desktop.
case NullableMethodId.ToString:
CheckArgumentCount(arguments, 0);
return(hasValue ? value.ToString() : "");
case NullableMethodId.Equals:
{
CheckArgumentCount(arguments, 1);
Object other = arguments[0];
if (!hasValue)
{
return(other == null);
}
if (other == null)
{
return(false);
}
return(value.Equals(other));
}
case NullableMethodId.GetHashCode:
CheckArgumentCount(arguments, 0);
return(hasValue ? value.GetHashCode() : 0);
case NullableMethodId.Ctor:
{
// Constructor case is tricky. Our implementation of NewObject() does not accept Nullable<T>'s so this is one of those cases
// where the constructor is responsible for both the allocation and initialization. Fortunately, we only have to return the boxed
// version of Nullable<T> which conveniently happens to be equal to the value we were passed in.
CheckArgumentCount(arguments, 1);
RuntimeTypeHandle theT = RuntimeAugments.GetNullableType(_nullableTypeHandle);
Object argument = RuntimeAugments.CheckArgument(arguments[0], theT);
return(argument);
}
case NullableMethodId.get_HasValue:
CheckArgumentCount(arguments, 0);
return(hasValue);
case NullableMethodId.get_Value:
CheckArgumentCount(arguments, 0);
if (!hasValue)
{
throw new InvalidOperationException(SR.InvalidOperation_NoValue);
}
return(value);
case NullableMethodId.GetValueOrDefault_0:
{
CheckArgumentCount(arguments, 0);
if (hasValue)
{
return(value);
}
RuntimeTypeHandle theT = RuntimeAugments.GetNullableType(_nullableTypeHandle);
return(RuntimeAugments.NewObject(theT));
}
case NullableMethodId.GetValueOrDefault_1:
{
CheckArgumentCount(arguments, 1);
RuntimeTypeHandle theT = RuntimeAugments.GetNullableType(_nullableTypeHandle);
Object defaultValue = RuntimeAugments.CheckArgument(arguments[0], theT);
return(hasValue ? value : defaultValue);
}
default:
throw new InvalidOperationException();
}
}
protected sealed override void SetFieldBypassCctor(Object obj, Object value, BinderBundle binderBundle)
{
value = RuntimeAugments.CheckArgument(value, FieldTypeHandle, binderBundle);
RuntimeAugments.StoreReferenceTypeField(_fieldAddress, value);
}
protected sealed override void SetFieldBypassCctor(object value, BinderBundle binderBundle)
{
value = RuntimeAugments.CheckArgument(value, FieldTypeHandle, binderBundle);
UncheckedSetFieldBypassCctor(value);
}
public sealed override Object Invoke(Object thisObject, Object[] arguments)
{
switch (_id)
{
case IntPtrConstructorId.Int32:
{
CheckArgumentCount(arguments, 1);
Int32 value = (Int32)(RuntimeAugments.CheckArgument(arguments[0], typeof(Int32).TypeHandle));
try
{
return(new IntPtr(value));
}
catch (Exception inner)
{
throw new TargetInvocationException(inner);
}
}
case IntPtrConstructorId.Int64:
{
CheckArgumentCount(arguments, 1);
Int64 value = (Int64)(RuntimeAugments.CheckArgument(arguments[0], typeof(Int64).TypeHandle));
try
{
return(new IntPtr(value));
}
catch (Exception inner)
{
throw new TargetInvocationException(inner);
}
}
case IntPtrConstructorId.UInt32:
{
CheckArgumentCount(arguments, 1);
UInt32 value = (UInt32)(RuntimeAugments.CheckArgument(arguments[0], typeof(UInt32).TypeHandle));
try
{
return(new UIntPtr(value));
}
catch (Exception inner)
{
throw new TargetInvocationException(inner);
}
}
case IntPtrConstructorId.UInt64:
{
CheckArgumentCount(arguments, 1);
UInt64 value = (UInt64)(RuntimeAugments.CheckArgument(arguments[0], typeof(UInt64).TypeHandle));
try
{
return(new UIntPtr(value));
}
catch (Exception inner)
{
throw new TargetInvocationException(inner);
}
}
default:
throw new InvalidOperationException();
}
}
