|
static private ExpressionTypeDoesNotMatchMethodParameter ( object p0, object p1, object p2, string paramName, int index ) : |
||
| p0 | object | |
| p1 | object | |
| p2 | object | |
| paramName | string | |
| index | int | |
| Результат | ||
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection <Expression> arguments)
{
if (indexes.Length > 0)
{
if (indexes.Length != arguments.Count)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
Expression[] newArgs = null;
var n = indexes.Length;
for (var i = 0; i < n; i++)
{
var arg = arguments[i];
var pi = indexes[i];
RequiresCanRead(arg, "arguments");
var pType = pi.ParameterType;
if (pType.IsByRef)
{
throw Error.AccessorsCannotHaveByRefArgs();
}
TypeHelper.ValidateType(pType);
if (!TypeHelper.AreReferenceAssignable(pType, arg.Type))
{
if (!TryQuote(pType, ref arg))
{
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method);
}
}
if (newArgs == null && arg != arguments[i])
{
newArgs = new Expression[arguments.Count];
for (var j = 0; j < i; j++)
{
newArgs[j] = arguments[j];
}
}
if (newArgs != null)
{
newArgs[i] = arg;
}
}
if (newArgs != null)
{
arguments = new TrueReadOnlyCollection <Expression>(newArgs);
}
}
else if (arguments.Count > 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
}
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref Expression[] arguments, string paramName)
{
if (indexes.Length > 0)
{
if (indexes.Length != arguments.Length)
{
throw Error.IncorrectNumberOfMethodCallArguments(method, paramName);
}
Expression[] newArgs = null;
for (int i = 0, n = indexes.Length; i < n; i++)
{
var arg = arguments[i];
var pi = indexes[i];
ExpressionUtils.RequiresCanRead(arg, nameof(arguments), i);
var pType = pi.ParameterType;
if (pType.IsByRef)
{
throw Error.AccessorsCannotHaveByRefArgs(nameof(indexes), i);
}
TypeUtils.ValidateType(pType, nameof(indexes), i);
if (!pType.IsReferenceAssignableFromInternal(arg.Type))
{
if (!TryQuote(pType, ref arg))
{
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method, nameof(arguments), i);
}
}
if (newArgs == null && arg != arguments[i])
{
newArgs = new Expression[arguments.Length];
for (var j = 0; j < i; j++)
{
newArgs[j] = arguments[j];
}
}
if (newArgs != null)
{
newArgs[i] = arg;
}
}
if (newArgs != null)
{
arguments = newArgs;
}
}
else if (arguments.Length > 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(method, paramName);
}
}
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection <Expression> arguments)
{
if (indexes.Length > 0)
{
if (indexes.Length != arguments.Count)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
Expression[] newArgs = null;
for (int i = 0, n = indexes.Length; i < n; i++)
{
Expression arg = arguments[i];
ParameterInfo pi = indexes[i];
RequiresCanRead(arg, "arguments");
Type pType = pi.ParameterType;
ContractUtils.Requires(!pType.IsByRef, "indexes", Strings.AccessorsCannotHaveByRefArgs);
TypeUtils.ValidateType(pType);
if (!TypeUtils.AreReferenceAssignable(pType, arg.Type))
{
if (TypeUtils.IsSameOrSubclass(typeof(Expression), pType) && pType.IsAssignableFrom(arg.GetType()))
{
arg = Expression.Quote(arg);
}
else
{
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method);
}
}
if (newArgs == null && arg != arguments[i])
{
newArgs = new Expression[arguments.Count];
for (int j = 0; j < i; j++)
{
newArgs[j] = arguments[j];
}
}
if (newArgs != null)
{
newArgs[i] = arg;
}
}
if (newArgs != null)
{
arguments = new ReadOnlyCollection <Expression>(newArgs);
}
}
else if (arguments.Count > 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
}
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection <Expression> arguments, string?paramName)
{
if (indexes.Length > 0)
{
if (indexes.Length != arguments.Count)
{
throw Error.IncorrectNumberOfMethodCallArguments(method, paramName);
}
Expression[]? newArgs = null;
for (int i = 0, n = indexes.Length; i < n; i++)
{
Expression arg = arguments[i];
ParameterInfo pi = indexes[i];
ExpressionUtils.RequiresCanRead(arg, nameof(arguments), i);
Type pType = pi.ParameterType;
if (pType.IsByRef)
{
throw Error.AccessorsCannotHaveByRefArgs(nameof(indexes), i);
}
TypeUtils.ValidateType(pType, nameof(indexes), i);
if (!TypeUtils.AreReferenceAssignable(pType, arg.Type))
{
if (!TryQuote(pType, ref arg))
{
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method, nameof(arguments), i);
}
}
if (newArgs == null && arg != arguments[i])
{
newArgs = new Expression[arguments.Count];
for (int j = 0; j < i; j++)
{
newArgs[j] = arguments[j];
}
}
if (newArgs != null)
{
newArgs[i] = arg;
}
}
if (newArgs != null)
{
arguments = new TrueReadOnlyCollection <Expression>(newArgs);
}
}
else if (arguments.Count > 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(method, paramName);
}
}
private static Expression ValidateOneArgument(MethodBase method, ExpressionType nodeKind, Expression arg, ParameterInfo pi)
{
RequiresCanRead(arg, "arguments");
Type pType = pi.ParameterType;
if (pType.IsByRef)
{
pType = pType.GetElementType();
}
TypeUtils.ValidateType(pType);
if (!TypeUtils.AreReferenceAssignable(pType, arg.Type))
{
if (TypeUtils.IsSameOrSubclass(typeof(Expression), pType) && pType.IsAssignableFrom(arg.GetType()))
{
arg = Expression.Quote(arg);
}
else
{
// TODO: this is for LinqV1 compat, can we just have one exception?
switch (nodeKind)
{
case ExpressionType.New:
throw Error.ExpressionTypeDoesNotMatchConstructorParameter(arg.Type, pType);
case ExpressionType.Invoke:
throw Error.ExpressionTypeDoesNotMatchParameter(arg.Type, pType);
case ExpressionType.Dynamic:
case ExpressionType.Call:
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method);
default:
throw Assert.Unreachable;
}
}
}
return(arg);
}
