| public abstract ChangeType ( object value, Type type, CultureInfo culture ) : object | ||
| value | object | |
| type | Type | |
| culture | CultureInfo | |
| return | object | |
internal static bool ConvertArgs(Binder binder, object[] args, ParameterInfo[] pinfo, CultureInfo culture)
{
if (args == null)
{
if (pinfo.Length == 0)
{
return(true);
}
else
{
throw new TargetParameterCountException();
}
}
if (pinfo.Length != args.Length)
{
throw new TargetParameterCountException();
}
for (int i = 0; i < args.Length; ++i)
{
object v = binder.ChangeType(args [i], pinfo[i].ParameterType, culture);
if ((v == null) && (args [i] != null))
{
return(false);
}
args [i] = v;
}
return(true);
}
public override void SetValue(object obj, object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
{
if (!IsStatic && obj == null)
{
throw new TargetException("Non-static field requires a target");
}
if (IsLiteral)
{
throw new FieldAccessException("Cannot set a constant field");
}
if (binder == null)
{
binder = Binder.DefaultBinder;
}
if (val != null)
{
object newVal;
newVal = binder.ChangeType(val, type, culture);
if (newVal == null)
{
throw new ArgumentException("Object type " + val.GetType() + " cannot be converted to target type: " + type, "val");
}
val = newVal;
}
SetValueInternal(this, obj, val);
}
internal static bool ConvertArgs (Binder binder, object[] args, ParameterInfo[] pinfo, CultureInfo culture) {
if (args == null) {
if ( pinfo.Length == 0)
return true;
else
throw new TargetParameterCountException ();
}
if (pinfo.Length != args.Length)
throw new TargetParameterCountException ();
for (int i = 0; i < args.Length; ++i) {
object v = binder.ChangeType (args [i], pinfo[i].ParameterType, culture);
if ((v == null) && (args [i] != null))
return false;
args [i] = v;
}
return true;
}
private object[] ConvertParams(int offset, object[] parameters, Binder binder, CultureInfo culture)
{
int length = this.formalParams.Length;
if (this.hasVarargs)
{
length--;
}
for (int i = offset; i < length; i++)
{
Type parameterType = this.formalParams[i].ParameterType;
if (parameterType != Typeob.Object)
{
parameters[i] = binder.ChangeType(parameters[i], parameterType, culture);
}
}
return parameters;
}
public override void SetValue(object obj, object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
{
if (!this.IsStatic)
{
if (obj == null)
{
throw new TargetException("Non-static field requires a target");
}
if (!this.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}.", this.Name, this.DeclaringType, obj.GetType()), "obj");
}
}
if (this.IsLiteral)
{
throw new FieldAccessException("Cannot set a constant field");
}
if (binder == null)
{
binder = Binder.DefaultBinder;
}
this.CheckGeneric();
if (val != null)
{
object obj2 = binder.ChangeType(val, this.type, culture);
if (obj2 == null)
{
throw new ArgumentException(string.Concat(new object[]
{
"Object type ",
val.GetType(),
" cannot be converted to target type: ",
this.type
}), "val");
}
val = obj2;
}
MonoField.SetValueInternal(this, obj, val);
}
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 = Binder.DefaultBinder;
CheckGeneric ();
if (val != null) {
object newVal;
newVal = binder.ChangeType (val, FieldType, culture);
if (newVal == null)
throw new ArgumentException ("Object type " + val.GetType() + " cannot be converted to target type: " + FieldType, "val");
val = newVal;
}
SetValueInternal (this, obj, val);
}
internal Object CheckValue (Object value, Binder binder, CultureInfo culture, BindingFlags invokeAttr)
{
bool failed = false;
var res = TryConvertToType (value, ref failed);
if (!failed)
return res;
if ((invokeAttr & BindingFlags.ExactBinding) == BindingFlags.ExactBinding)
throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Arg_ObjObjEx"), value.GetType(), this));
if (binder != null && binder != Type.DefaultBinder)
return binder.ChangeType (value, this, culture);
throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Arg_ObjObjEx"), value.GetType(), this));
}
private static object[] LickArgumentsIntoShape(ParameterInfo[] pars, object[] arguments, Binder binder, CultureInfo culture)
{
if (arguments == null)
{
return null;
}
int length = pars.Length;
if (length == 0)
{
return null;
}
object[] objArray = arguments;
int num2 = arguments.Length;
if (num2 != length)
{
objArray = new object[length];
}
int index = length - 1;
int num4 = (num2 < index) ? num2 : index;
for (int i = 0; i < num4; i++)
{
object obj2 = arguments[i];
if (obj2 is DBNull)
{
objArray[i] = null;
}
else
{
objArray[i] = binder.ChangeType(arguments[i], pars[i].ParameterType, culture);
}
}
for (int j = num4; j < index; j++)
{
object defaultParameterValue = TypeReferences.GetDefaultParameterValue(pars[j]);
if (defaultParameterValue == System.Convert.DBNull)
{
defaultParameterValue = binder.ChangeType(null, pars[j].ParameterType, culture);
}
objArray[j] = defaultParameterValue;
}
if (Microsoft.JScript.CustomAttribute.IsDefined(pars[index], typeof(ParamArrayAttribute), false))
{
int num7 = num2 - index;
if (num7 < 0)
{
num7 = 0;
}
Type elementType = pars[index].ParameterType.GetElementType();
Array array = Array.CreateInstance(elementType, num7);
for (int k = 0; k < num7; k++)
{
array.SetValue(binder.ChangeType(arguments[k + index], elementType, culture), k);
}
objArray[index] = array;
return objArray;
}
if (num2 < length)
{
object obj4 = TypeReferences.GetDefaultParameterValue(pars[index]);
if (obj4 == System.Convert.DBNull)
{
obj4 = binder.ChangeType(null, pars[index].ParameterType, culture);
}
objArray[index] = obj4;
return objArray;
}
objArray[index] = binder.ChangeType(arguments[index], pars[index].ParameterType, culture);
return objArray;
}
private Object[] ConvertParams(int offset, Object[] parameters, Binder binder, CultureInfo culture){
int n = this.formalParams.Length;
if (this.hasVarargs) n--;
for (int i = offset; i < n; i++){
Type fpt = this.formalParams[i].ParameterType;
if (fpt != Typeob.Object)
parameters[i] = binder.ChangeType(parameters[i], fpt, culture);
}
return parameters;
}
public override object ChangeType(object value, Type type, CultureInfo culture)
{
return(_binder.ChangeType(value, type, culture));
}
private static Array CopyToNewParamArray(Type t, int n, object[] args, int offset, Binder binder, CultureInfo culture)
{
Array array = Array.CreateInstance(t, n);
for (int i = 0; i < n; i++)
{
array.SetValue(binder.ChangeType(args[i + offset], t, culture), i);
}
return array;
}
private void ConvertArguments(object[] args, object[] newargs, int offset, int length, int n, Binder binder, CultureInfo culture)
{
ParameterInfo[] parameterInfos = this.parameterInfos;
if (parameterInfos != null)
{
int num = 0;
for (int i = offset; num < n; i++)
{
Type parameterType = parameterInfos[i].ParameterType;
if ((num == (n - 1)) && Microsoft.JScript.CustomAttribute.IsDefined(parameterInfos[i], typeof(ParamArrayAttribute), false))
{
int num3 = length - num;
if (num3 < 0)
{
num3 = 0;
}
newargs[i] = CopyToNewParamArray(parameterType.GetElementType(), num3, args, num, binder, culture);
return;
}
object obj2 = (num < length) ? args[num] : null;
if (parameterType == Typeob.Object)
{
newargs[i] = obj2;
}
else if (binder != null)
{
newargs[i] = binder.ChangeType(obj2, parameterType, culture);
}
else
{
newargs[i] = Microsoft.JScript.Convert.CoerceT(obj2, parameterType);
}
num++;
}
}
else
{
ParameterDeclaration[] declarationArray = this.parameter_declarations;
int index = 0;
for (int j = offset; index < n; j++)
{
IReflect parameterIReflect = declarationArray[index].ParameterIReflect;
if ((index == (n - 1)) && Microsoft.JScript.CustomAttribute.IsDefined(declarationArray[j], typeof(ParamArrayAttribute), false))
{
int num6 = length - index;
if (num6 < 0)
{
num6 = 0;
}
newargs[j] = CopyToNewParamArray(((TypedArray) parameterIReflect).elementType, num6, args, index);
return;
}
object obj3 = (index < length) ? args[index] : null;
if (parameterIReflect == Typeob.Object)
{
newargs[j] = obj3;
}
else if (parameterIReflect is ClassScope)
{
newargs[j] = Microsoft.JScript.Convert.Coerce(obj3, parameterIReflect);
}
else if (binder != null)
{
newargs[j] = binder.ChangeType(obj3, Microsoft.JScript.Convert.ToType(parameterIReflect), culture);
}
else
{
newargs[j] = Microsoft.JScript.Convert.CoerceT(obj3, Microsoft.JScript.Convert.ToType(parameterIReflect));
}
index++;
}
}
}
private static System.Array CopyToNewParamArray(Type t, int n, Object[] args, int offset, Binder binder, CultureInfo culture){
System.Array paramArray = System.Array.CreateInstance(t, n);
for (int i = 0; i < n; i++)
paramArray.SetValue(binder.ChangeType(args[i+offset], t, culture), i);
return paramArray;
}
private void ConvertArguments(Object[] args, Object[] newargs, int offset, int length, int n, Binder binder, CultureInfo culture){
ParameterInfo[] pars = this.parameterInfos;
if (pars != null){
for (int i = 0, j = offset; i < n; i++, j++){
Type t = pars[j].ParameterType;
if (i == n-1 && pars[j].IsDefined(Typeob.ParamArrayAttribute, false)){
int k = length-i; if (k < 0) k = 0;
newargs[j] = FunctionObject.CopyToNewParamArray(t.GetElementType(), k, args, i, binder, culture);
return;
}
Object argval = i < length ? args[i] : null;
if (t == Typeob.Object)
newargs[j] = argval;
else if (binder != null)
newargs[j] = binder.ChangeType(argval, t, culture);
else
newargs[j] = Convert.CoerceT(argval, t);
}
}else{
ParameterDeclaration[] pds = this.parameter_declarations;
for (int i = 0, j = offset; i < n; i++, j++){
IReflect ir = pds[i].ParameterIReflect;
if (i == n-1 && pds[j].IsDefined(Typeob.ParamArrayAttribute, false)){
int k = length-i; if (k < 0) k = 0;
newargs[j] = FunctionObject.CopyToNewParamArray(((TypedArray)ir).elementType, k, args, i);
return;
}
Object argval = i < length ? args[i] : null;
if (ir == Typeob.Object){
newargs[j] = argval; continue;
}
if (ir is ClassScope)
newargs[j] = Convert.Coerce(argval, ir);
else if (binder != null)
newargs[j] = binder.ChangeType(argval, Convert.ToType(ir), culture);
else
newargs[j] = Convert.CoerceT(argval, Convert.ToType(ir));
}
}
}
//Do not call this method for arguments that are going out to COM2 objects via interop.
private static Object[] LickArgumentsIntoShape(ParameterInfo[] pars, Object[] arguments, Binder binder, CultureInfo culture){
if (arguments == null)
return null;
int formals = pars.Length;
if (formals == 0)
return null;
Object[] newArgs = arguments;
int actuals = arguments.Length;
if (actuals != formals)
newArgs = new Object[formals];
int m = formals-1; //Position of last formal param
int k = actuals < m ? actuals : m; //Number of formal params that have corresponding actual arguments, bar the last one, which may be a varArg array.
//Copy all actual args that match formal param, bar the last one. Change DBNull to null. Coerce actual value to formal param type.
for (int i = 0; i < k; i++){
Object arg = arguments[i];
if (arg is DBNull)
newArgs[i] = null; //Outside of the world of OLE Variants, undefined == null == the null pointer.
else
newArgs[i] = binder.ChangeType(arguments[i], pars[i].ParameterType, culture);
}
//Supply default values for all formal params, bar the last one, that do not have corresponding actual arguments
for (int i = k; i < m; i++){
Object dv = pars[i].DefaultValue;
if (dv == System.Convert.DBNull) //No default value was specified
dv = binder.ChangeType(null, pars[i].ParameterType, culture); //Substitute undefined
newArgs[i] = dv;
}
//If the last formal param is a vararg param, treat it specially.
if (pars[m].IsDefined(Typeob.ParamArrayAttribute, false)){
int numVarArgs = actuals - m;
if (numVarArgs < 0) numVarArgs = 0;
Type t = pars[m].ParameterType.GetElementType();
Array pa = Array.CreateInstance(t, numVarArgs);
for (int j = 0; j < numVarArgs; j++)
pa.SetValue(binder.ChangeType(arguments[j+m], t, culture), j);
newArgs[m] = pa;
}else if (actuals < formals){
Object dv = pars[m].DefaultValue;
if (dv == System.Convert.DBNull) //No default value was specified
dv = binder.ChangeType(null, pars[m].ParameterType, culture); //Substitute undefined
newArgs[m] = dv;
}else
newArgs[m] = binder.ChangeType(arguments[m], pars[m].ParameterType, culture);
return newArgs;
}
public override void SetValue (object obj, object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
{
if (!IsStatic && obj == null)
throw new TargetException ("Non-static field requires a target");
if (IsLiteral)
throw new FieldAccessException ("Cannot set a constant field");
if (binder == null)
binder = Binder.DefaultBinder;
CheckGeneric ();
if (val != null) {
object newVal;
newVal = binder.ChangeType (val, type, culture);
if (newVal == null)
throw new ArgumentException ("Object type " + val.GetType() + " cannot be converted to target type: " + type, "val");
val = newVal;
}
SetValueInternal (this, obj, val);
}
