private static ClientQueryInternal ProcessClientQueryableMethodCallQueryExpression(
            ClientQueryInternal rootQuery, ClientObject rootClientObject,
            MethodCallExpression exp, bool leaf,
            DataRetrieval.QueryProcessInfo queryInfo, DataRetrieval.QueryMethodAggregator aggregator)
        {
            //Edited for .NET Core
            string name;

            if ((name = exp.Method.Name) != null)
            {
                //Edited for .NET Core
                // This was bugged when reflecting the source, wo it needs checking
                var newDictionary = new Dictionary <string, int>(8)
                {
                    {
                        "Where",
                        0
                    },
                    {
                        "OrderBy",
                        1
                    },
                    {
                        "OrderByDescending",
                        2
                    },
                    {
                        "ThenBy",
                        3
                    },
                    {
                        "ThenByDescending",
                        4
                    },
                    {
                        "Select",
                        5
                    },
                    {
                        "Take",
                        6
                    },
                    {
                        "OfType",
                        7
                    }
                };
                int num;
                if (newDictionary.TryGetValue(name, out num))
                {
                    ClientQueryInternal result;
                    switch (num)
                    {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    {
                        ClientQueryInternal clientQueryInternal = DataRetrieval.ProcessQueryExpression(rootQuery, rootClientObject, exp.Arguments[0], leaf, queryInfo, aggregator);
                        string name2;
                        if ((name2 = exp.Method.Name) != null)
                        {
                            if (!(name2 == "Where"))
                            {
                                if (!(name2 == "OrderBy"))
                                {
                                    if (name2 == "OrderByDescending")
                                    {
                                        aggregator.OrderByDescending++;
                                    }
                                }
                                else
                                {
                                    aggregator.OrderBy++;
                                }
                            }
                            else
                            {
                                aggregator.Where++;
                            }
                        }
                        Expression       expression       = ExpressionUtility.StripQuotes(exp.Arguments[1]);
                        LambdaExpression lambdaExpression = expression as LambdaExpression;
                        if (lambdaExpression == null)
                        {
                            throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                        }
                        ChunkStringBuilder chunkStringBuilder = new ChunkStringBuilder();
                        XmlWriter          xmlWriter          = chunkStringBuilder.CreateXmlWriter();
                        string             name3;
                        if ((name3 = exp.Method.Name) != null)
                        {
                            if (!(name3 == "Where"))
                            {
                                if (!(name3 == "OrderBy"))
                                {
                                    if (!(name3 == "OrderByDescending"))
                                    {
                                        if (!(name3 == "ThenBy"))
                                        {
                                            if (!(name3 == "ThenByDescending"))
                                            {
                                                goto IL_224;
                                            }
                                            xmlWriter.WriteStartElement("ThenByDescending");
                                        }
                                        else
                                        {
                                            xmlWriter.WriteStartElement("ThenBy");
                                        }
                                    }
                                    else
                                    {
                                        xmlWriter.WriteStartElement("OrderByDescending");
                                    }
                                }
                                else
                                {
                                    xmlWriter.WriteStartElement("OrderBy");
                                }
                            }
                            else
                            {
                                xmlWriter.WriteStartElement("Where");
                            }
                            ClientQueryInternal.WriteFilterExpressionToXml(xmlWriter, clientQueryInternal.ChildItemQuery.ChildItemExpressionSerializationContext, lambdaExpression);
                            xmlWriter.WriteStartElement("Object");
                            ChunkStringBuilder chunkStringBuilder2 = null;
                            if (queryInfo.Expression.TryGetValue(clientQueryInternal.ChildItemQuery, out chunkStringBuilder2))
                            {
                                chunkStringBuilder2.WriteContentAsRawXml(xmlWriter);
                            }
                            else
                            {
                                xmlWriter.WriteStartElement("QueryableObject");
                                xmlWriter.WriteEndElement();
                            }
                            xmlWriter.WriteEndElement();
                            xmlWriter.WriteEndElement();
                            xmlWriter.Dispose();
                            queryInfo.Expression[clientQueryInternal.ChildItemQuery] = chunkStringBuilder;
                            result = clientQueryInternal;
                            break;
                        }
IL_224:
                        throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                    }

                    case 5:
                    {
                        DataRetrieval.CheckSelectExpression(exp);
                        ClientQueryInternal clientQueryInternal2 = DataRetrieval.ProcessQueryExpression(rootQuery, rootClientObject, exp.Arguments[0], leaf, queryInfo, aggregator);
                        aggregator.Select++;
                        result = clientQueryInternal2;
                        queryInfo.BySelect[clientQueryInternal2.ChildItemQuery.Id] = clientQueryInternal2.ChildItemQuery;
                        break;
                    }

                    case 6:
                    {
                        ClientQueryInternal clientQueryInternal3 = DataRetrieval.ProcessQueryExpression(rootQuery, rootClientObject, exp.Arguments[0], leaf, queryInfo, aggregator);
                        aggregator.Take++;
                        Expression expression2 = exp.Arguments[1];
                        expression2 = ExpressionEvaluator.PartialEvaluate(expression2, new Func <Expression, bool>(DataRetrieval.ExpectConstantExpression_CanExpressionBeEvaluated));
                        if (expression2.NodeType != ExpressionType.Constant || expression2.Type != typeof(int))
                        {
                            throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                        }
                        ConstantExpression constantExpression = (ConstantExpression)expression2;
                        int num2 = (int)constantExpression.Value;
                        if (num2 < 0)
                        {
                            throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                        }
                        ChunkStringBuilder chunkStringBuilder3 = new ChunkStringBuilder();
                        XmlWriter          xmlWriter2          = chunkStringBuilder3.CreateXmlWriter();
                        xmlWriter2.WriteStartElement("Take");
                        xmlWriter2.WriteAttributeString("Count", num2.ToString(CultureInfo.InvariantCulture));
                        ChunkStringBuilder chunkStringBuilder4 = null;
                        if (queryInfo.Expression.TryGetValue(clientQueryInternal3.ChildItemQuery, out chunkStringBuilder4))
                        {
                            chunkStringBuilder4.WriteContentAsRawXml(xmlWriter2);
                        }
                        else
                        {
                            xmlWriter2.WriteStartElement("QueryableObject");
                            xmlWriter2.WriteEndElement();
                        }
                        xmlWriter2.WriteEndElement();
                        xmlWriter2.Dispose();
                        queryInfo.Expression[clientQueryInternal3.ChildItemQuery] = chunkStringBuilder3;
                        result = clientQueryInternal3;
                        break;
                    }

                    case 7:
                    {
                        ClientQueryInternal clientQueryInternal4 = DataRetrieval.ProcessQueryExpression(rootQuery, rootClientObject, exp.Arguments[0], leaf, queryInfo, aggregator);
                        if (!exp.Method.IsGenericMethod || exp.Method.ContainsGenericParameters)
                        {
                            throw new InvalidQueryExpressionException(Resources.GetString("NotSupportedQueryExpressionWithExpressionValue", new object[]
                                {
                                    exp.ToString()
                                }));
                        }
                        Type[] genericArguments = exp.Method.GetGenericArguments();
                        if (genericArguments == null || genericArguments.Length != 1)
                        {
                            throw new InvalidQueryExpressionException(Resources.GetString("NotSupportedQueryExpressionWithExpressionValue", new object[]
                                {
                                    exp.ToString()
                                }));
                        }
                        string value  = null;
                        string value2 = null;
                        DataConvert.GetTypeNameOrTypeId(genericArguments[0], out value, out value2);
                        if (string.IsNullOrEmpty(value) && string.IsNullOrEmpty(value2))
                        {
                            throw new InvalidQueryExpressionException(Resources.GetString("NotSupportedQueryExpressionWithExpressionValue", new object[]
                                {
                                    exp.ToString()
                                }));
                        }
                        ChunkStringBuilder chunkStringBuilder5 = new ChunkStringBuilder();
                        XmlWriter          xmlWriter3          = chunkStringBuilder5.CreateXmlWriter();
                        xmlWriter3.WriteStartElement("OfType");
                        if (!string.IsNullOrEmpty(value))
                        {
                            xmlWriter3.WriteAttributeString("Type", value);
                        }
                        else
                        {
                            xmlWriter3.WriteAttributeString("TypeId", value2);
                        }
                        ChunkStringBuilder chunkStringBuilder6 = null;
                        if (queryInfo.Expression.TryGetValue(clientQueryInternal4.ChildItemQuery, out chunkStringBuilder6))
                        {
                            chunkStringBuilder6.WriteContentAsRawXml(xmlWriter3);
                        }
                        else
                        {
                            xmlWriter3.WriteStartElement("QueryableObject");
                            xmlWriter3.WriteEndElement();
                        }
                        xmlWriter3.WriteEndElement();
                        xmlWriter3.Dispose();
                        queryInfo.Expression[clientQueryInternal4.ChildItemQuery] = chunkStringBuilder5;
                        result = clientQueryInternal4;
                        break;
                    }

                    default:
                        goto IL_5B7;
                    }
                    return(result);
                }
            }
IL_5B7:
            throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
        }
        private static ClientQueryInternal ProcessMethodCallQueryExpression(ClientQueryInternal rootQuery, ClientObject rootClientObject, MethodCallExpression exp, bool leaf, DataRetrieval.QueryProcessInfo queryInfo, DataRetrieval.QueryMethodAggregator aggregator)
        {
            ClientQueryInternal result;

            if (exp.Method.IsGenericMethod && (exp.Method.DeclaringType == typeof(Enumerable) || exp.Method.DeclaringType == typeof(System.Linq.Queryable)))
            {
                result = DataRetrieval.ProcessClientQueryableMethodCallQueryExpression(rootQuery, rootClientObject, exp, leaf, queryInfo, aggregator);
            }
            else if (exp.Method.IsGenericMethod && exp.Method.DeclaringType == typeof(ClientObjectQueryableExtension) && (exp.Method.Name == "Include" || exp.Method.Name == "IncludeWithDefaultProperties"))
            {
                if (exp.Arguments.Count != 2)
                {
                    throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                }
                IEnumerable <Expression> enumerable         = null;
                NewArrayExpression       newArrayExpression = exp.Arguments[1] as NewArrayExpression;
                if (newArrayExpression == null)
                {
                    Expression expression = ExpressionEvaluator.PartialEvaluate(exp.Arguments[1], new Func <Expression, bool>(DataRetrieval.ExpectConstantExpression_CanExpressionBeEvaluated));
                    if (expression.NodeType == ExpressionType.Constant)
                    {
                        ConstantExpression constantExpression = (ConstantExpression)expression;
                        enumerable = (constantExpression.Value as IEnumerable <Expression>);
                    }
                    if (enumerable == null)
                    {
                        throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                    }
                }
                else
                {
                    enumerable = newArrayExpression.Expressions;
                }
                ClientQueryInternal clientQueryInternal = DataRetrieval.ProcessQueryExpression(rootQuery, rootClientObject, exp.Arguments[0], false, queryInfo, aggregator);
                aggregator.Include++;
                if (clientQueryInternal == null)
                {
                    throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                }
                queryInfo.ByInclude[clientQueryInternal.ChildItemQuery.Id] = clientQueryInternal.ChildItemQuery;
                ClientQueryInternal childItemQuery = clientQueryInternal.ChildItemQuery;
                if (exp.Method.Name == "IncludeWithDefaultProperties")
                {
                    childItemQuery.SelectAllProperties();
                }
                foreach (Expression current in enumerable)
                {
                    Expression       expression2      = ExpressionUtility.StripQuotes(current);
                    LambdaExpression lambdaExpression = expression2 as LambdaExpression;
                    if (lambdaExpression == null)
                    {
                        expression2 = ExpressionEvaluator.PartialEvaluate(expression2, new Func <Expression, bool>(DataRetrieval.ExpectConstantExpression_CanExpressionBeEvaluated));
                        ConstantExpression constantExpression2 = expression2 as ConstantExpression;
                        if (constantExpression2 != null)
                        {
                            lambdaExpression = (constantExpression2.Value as LambdaExpression);
                        }
                        if (lambdaExpression == null)
                        {
                            throw DataRetrieval.CreateInvalidQueryExpressionException(expression2);
                        }
                    }
                    Expression exp2 = lambdaExpression.Body;
                    exp2 = ExpressionUtility.StripConverts(exp2);
                    DataRetrieval.QueryMethodAggregator queryMethodAggregator = new DataRetrieval.QueryMethodAggregator(current);
                    DataRetrieval.ProcessQueryExpression(childItemQuery, null, exp2, true, queryInfo, queryMethodAggregator);
                    queryMethodAggregator.Check();
                }
                result = clientQueryInternal;
            }
            else
            {
                if (!ExpressionUtility.IsGetFieldValueMethod(exp.Method))
                {
                    throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                }
                ClientQueryInternal clientQueryInternal2 = DataRetrieval.ProcessQueryExpression(rootQuery, rootClientObject, exp.Object, false, queryInfo, aggregator);
                aggregator.Member++;
                if (clientQueryInternal2 == null)
                {
                    throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                }
                Expression expression3 = exp.Arguments[0];
                expression3 = ExpressionEvaluator.PartialEvaluate(expression3, new Func <Expression, bool>(DataRetrieval.ExpectConstantExpression_CanExpressionBeEvaluated));
                if (expression3.NodeType != ExpressionType.Constant || expression3.Type != typeof(string))
                {
                    throw DataRetrieval.CreateInvalidQueryExpressionException(exp);
                }
                ConstantExpression constantExpression3 = (ConstantExpression)expression3;
                clientQueryInternal2.Select((string)constantExpression3.Value);
                result = null;
            }
            return(result);
        }