ValidateLambdaArgs()

static void System.Linq.Expressions.Expression< TDelegate >.ValidateLambdaArgs ( Type delegateType, ref Expression< TDelegate > body, ReadOnlyCollection< ParameterExpression< TDelegate > > parameters, string paramName )

inlinestaticprivateinherited

Definition at line 3381 of file Expression.cs.

    {
        ContractUtils.RequiresNotNull(delegateType, "delegateType");
        ExpressionUtils.RequiresCanRead(body, "body");
        if (!typeof(MulticastDelegate).IsAssignableFrom(delegateType) || delegateType == typeof(MulticastDelegate))
        {
            throw Error.LambdaTypeMustBeDerivedFromSystemDelegate(paramName);
        }
        TypeUtils.ValidateType(delegateType, "delegateType", allowByRef: true, allowPointer: true);
        CacheDict<Type, MethodInfo> cacheDict = s_lambdaDelegateCache;
        if (!cacheDict.TryGetValue(delegateType, out var value))
        {
            value = delegateType.GetInvokeMethod();
            if (!delegateType.IsCollectible)
            {
                cacheDict[delegateType] = value;
            }
        }
        ParameterInfo[] parametersCached = value.GetParametersCached();
        if (parametersCached.Length != 0)
        {
            if (parametersCached.Length != parameters.Count)
            {
                throw Error.IncorrectNumberOfLambdaDeclarationParameters();
            }
            HashSet<ParameterExpression> hashSet = new HashSet<ParameterExpression>();
            int i = 0;
            for (int num = parametersCached.Length; i < num; i++)
            {
                ParameterExpression parameterExpression = parameters[i];
                ParameterInfo parameterInfo = parametersCached[i];
                ExpressionUtils.RequiresCanRead(parameterExpression, "parameters", i);
                Type type = parameterInfo.ParameterType;
                if (parameterExpression.IsByRef)
                {
                    if (!type.IsByRef)
                    {
                        throw Error.ParameterExpressionNotValidAsDelegate(parameterExpression.Type.MakeByRefType(), type);
                    }
                    type = type.GetElementType();
                }
                if (!TypeUtils.AreReferenceAssignable(parameterExpression.Type, type))
                {
                    throw Error.ParameterExpressionNotValidAsDelegate(parameterExpression.Type, type);
                }
                if (!hashSet.Add(parameterExpression))
                {
                    throw Error.DuplicateVariable(parameterExpression, "parameters", i);
                }
            }
        }
        else if (parameters.Count > 0)
        {
            throw Error.IncorrectNumberOfLambdaDeclarationParameters();
        }
        if (value.ReturnType != typeof(void) && !TypeUtils.AreReferenceAssignable(value.ReturnType, body.Type) && !TryQuote(value.ReturnType, ref body))
        {
            throw Error.ExpressionTypeDoesNotMatchReturn(body.Type, value.ReturnType);
        }
    }

References System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.Dynamic.Utils.TypeUtils.AreReferenceAssignable(), System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Linq.Expressions.Error.DuplicateVariable(), System.Linq.Expressions.Error.ExpressionTypeDoesNotMatchReturn(), System.Linq.Expressions.Error.IncorrectNumberOfLambdaDeclarationParameters(), System.Linq.Expressions.Error.LambdaTypeMustBeDerivedFromSystemDelegate(), System.Linq.Expressions.Error.ParameterExpressionNotValidAsDelegate(), System.Dynamic.Utils.ExpressionUtils.RequiresCanRead(), System.Dynamic.Utils.ContractUtils.RequiresNotNull(), System.Linq.Expressions.Expression< TDelegate >.s_lambdaDelegateCache, System.Collections.Generic.Dictionary< TKey, TValue >.TryGetValue(), System.Linq.Expressions.Expression< TDelegate >.TryQuote(), System.type, System.Dynamic.Utils.TypeUtils.ValidateType(), and System.value.

Referenced by System.Linq.Expressions.Expression< TDelegate >.Lambda(), System.Linq.Expressions.Expression< TDelegate >.Lambda(), and System.Linq.Expressions.Expression< TDelegate >.Lambda< TDelegate >().