◆ Switch() [5/6]

static SwitchExpression System.Linq.Expressions.Expression< TDelegate >.Switch	(	Type?	type,
		Expression< TDelegate >	switchValue,
		Expression< TDelegate >?	defaultBody,
		MethodInfo?	comparison,
		IEnumerable< SwitchCase >?	cases )
inlinestaticinherited
Definition at line 4752 of file Expression.cs.
    {
        ExpressionUtils.RequiresCanRead(switchValue, "switchValue");
        if (switchValue.Type == typeof(void))
        {
            throw Error.ArgumentCannotBeOfTypeVoid("switchValue");
        }
        ReadOnlyCollection<SwitchCase> readOnlyCollection = cases.ToReadOnly();
        ContractUtils.RequiresNotNullItems(readOnlyCollection, "cases");
        Type type2 = ((type != null) ? type : ((readOnlyCollection.Count != 0) ? readOnlyCollection[0].Body.Type : ((defaultBody == null) ? typeof(void) : defaultBody.Type)));
        bool customType = type != null;
        if (comparison != null)
        {
            ValidateMethodInfo(comparison, "comparison");
            ParameterInfo[] parametersCached = comparison.GetParametersCached();
            if (parametersCached.Length != 2)
            {
                throw Error.IncorrectNumberOfMethodCallArguments(comparison, "comparison");
            }
            ParameterInfo parameterInfo = parametersCached[0];
            bool flag = false;
            if (!ParameterIsAssignable(parameterInfo, switchValue.Type))
            {
                flag = ParameterIsAssignable(parameterInfo, switchValue.Type.GetNonNullableType());
                if (!flag)
                {
                    throw Error.SwitchValueTypeDoesNotMatchComparisonMethodParameter(switchValue.Type, parameterInfo.ParameterType);
                }
            }
            ParameterInfo parameterInfo2 = parametersCached[1];
            foreach (SwitchCase item in readOnlyCollection)
            {
                ContractUtils.RequiresNotNull(item, "cases");
                ValidateSwitchCaseType(item.Body, customType, type2, "cases");
                int i = 0;
                for (int count = item.TestValues.Count; i < count; i++)
                {
                    Type type3 = item.TestValues[i].Type;
                    if (flag)
                    {
                        if (!type3.IsNullableType())
                        {
                            throw Error.TestValueTypeDoesNotMatchComparisonMethodParameter(type3, parameterInfo2.ParameterType);
                        }
                        type3 = type3.GetNonNullableType();
                    }
                    if (!ParameterIsAssignable(parameterInfo2, type3))
                    {
                        throw Error.TestValueTypeDoesNotMatchComparisonMethodParameter(type3, parameterInfo2.ParameterType);
                    }
                }
            }
            if (comparison.ReturnType != typeof(bool))
            {
                throw Error.EqualityMustReturnBoolean(comparison, "comparison");
            }
        }
        else if (readOnlyCollection.Count != 0)
        {
            Expression expression = readOnlyCollection[0].TestValues[0];
            foreach (SwitchCase item2 in readOnlyCollection)
            {
                ContractUtils.RequiresNotNull(item2, "cases");
                ValidateSwitchCaseType(item2.Body, customType, type2, "cases");
                int j = 0;
                for (int count2 = item2.TestValues.Count; j < count2; j++)
                {
                    if (!TypeUtils.AreEquivalent(expression.Type, item2.TestValues[j].Type))
                    {
                        throw Error.AllTestValuesMustHaveSameType("cases");
                    }
                }
            }
            BinaryExpression binaryExpression = Equal(switchValue, expression, liftToNull: false, comparison);
            comparison = binaryExpression.Method;
        }
        if (defaultBody == null)
        {
            if (type2 != typeof(void))
            {
                throw Error.DefaultBodyMustBeSupplied("defaultBody");
            }
        }
        else
        {
            ValidateSwitchCaseType(defaultBody, customType, type2, "defaultBody");
        }
        return new SwitchExpression(type2, switchValue, defaultBody, comparison, readOnlyCollection);
    }