Esempio n. 1
0
        internal static void GetTypeNameOrTypeId(Type type, out string typeName, out string typeId)
        {
            typeName = null;
            typeId   = null;
            //Edited for .NET Core
            //if (type.IsEnum)
            if (type.GetTypeInfo().IsEnum)
            {
                type = Enum.GetUnderlyingType(type);
            }
            if (type.GetTypeInfo().IsPrimitive || type == typeof(string) || type == typeof(decimal) || type == typeof(DateTime))
            {
                typeName = DataConvert.GetTypeName(type);
                return;
            }
            //Edited for .NET Core
            //ScriptTypeAttribute scriptTypeAttribute = (ScriptTypeAttribute)Attribute.GetCustomAttribute(type, typeof(ScriptTypeAttribute));
            ScriptTypeAttribute scriptTypeAttribute = type.GetTypeInfo().GetCustomAttribute <ScriptTypeAttribute>();

            if (scriptTypeAttribute != null)
            {
                typeId = scriptTypeAttribute.ServerTypeId;
            }
        }
        //Edited for .NET Core
        private void Write(Expression exp)
        {
            ExpressionType nodeType = exp.NodeType;

            switch (nodeType)
            {
            case ExpressionType.AndAlso:
            case ExpressionType.GreaterThan:
            case ExpressionType.GreaterThanOrEqual:
            case ExpressionType.LessThan:
            case ExpressionType.LessThanOrEqual:
                break;

            case ExpressionType.ArrayLength:
            case ExpressionType.ArrayIndex:
            case ExpressionType.Coalesce:
            case ExpressionType.Conditional:
            case ExpressionType.Divide:
            case ExpressionType.ExclusiveOr:
            case ExpressionType.Invoke:
            case ExpressionType.Lambda:
            case ExpressionType.LeftShift:
            case ExpressionType.ListInit:
                goto IL_71A;

            case ExpressionType.Call:
            {
                MethodCallExpression methodCallExpression = (MethodCallExpression)exp;
                bool flag = false;
                if (methodCallExpression.Object == null)
                {
                    flag = true;
                    this.m_writer.WriteStartElement("ExpressionStaticMethod");
                    string serverTypeId = ConditionalExpressionToXmlConverter.GetServerTypeId(methodCallExpression.Method.DeclaringType);
                    if (string.IsNullOrEmpty(serverTypeId))
                    {
                        throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
                            {
                                this.m_condition.ToString()
                            }));
                    }
                    this.m_writer.WriteAttributeString("TypeId", serverTypeId);
                    this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(methodCallExpression.Method));
                }
                else
                {
                    this.m_writer.WriteStartElement("ExpressionMethod");
                    this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(methodCallExpression.Method));
                    this.Write(methodCallExpression.Object);
                }
                this.m_writer.WriteStartElement("Parameters");
                foreach (Expression current in methodCallExpression.Arguments)
                {
                    if (flag)
                    {
                        flag = false;
                    }
                    else
                    {
                        this.Write(current);
                    }
                }
                this.m_writer.WriteEndElement();
                this.m_writer.WriteEndElement();
                return;
            }

            case ExpressionType.Constant:
            {
                ConstantExpression constantExpression = (ConstantExpression)exp;
                object             value = constantExpression.Value;

                //Edited for .NET Core
                //if (value == null || value is ClientObject || value is ClientValueObject || value.GetType().IsPrimitive || value.GetType().IsEnum || value.GetType() == typeof(Guid) || value.GetType() == typeof(DateTime) || value.GetType() == typeof(string))
                if (value == null || value is ClientObject || value is ClientValueObject || value.GetType().GetTypeInfo().IsPrimitive || value.GetType().GetTypeInfo().IsEnum || value.GetType() == typeof(Guid) || value.GetType() == typeof(DateTime) || value.GetType() == typeof(string))
                {
                    this.m_writer.WriteStartElement("ExpressionConstant");
                    DataConvert.WriteValueToXmlElement(this.m_writer, value, this.m_serializationContext);
                    this.m_writer.WriteEndElement();
                    return;
                }
                throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
                    {
                        this.m_condition.ToString()
                    }));
            }

            case ExpressionType.Convert:
            case ExpressionType.ConvertChecked:
            {
                UnaryExpression unaryExpression = (UnaryExpression)exp;
                string          value2          = null;
                string          value3          = null;
                DataConvert.GetTypeNameOrTypeId(unaryExpression.Type, out value2, out value3);
                if (!string.IsNullOrEmpty(value2))
                {
                    this.m_writer.WriteStartElement("ExpressionConvert");
                    this.m_writer.WriteAttributeString("Type", value2);
                    this.Write(unaryExpression.Operand);
                    this.m_writer.WriteEndElement();
                    return;
                }
                if (string.IsNullOrEmpty(value3))
                {
                    throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
                        {
                            this.m_condition.ToString()
                        }));
                }
                if (this.m_serializationContext.Context.RequestSchemaVersion >= ClientSchemaVersions.Version15)
                {
                    this.m_writer.WriteStartElement("ExpressionConvert");
                    this.m_writer.WriteAttributeString("TypeId", value3);
                    this.Write(unaryExpression.Operand);
                    this.m_writer.WriteEndElement();
                    return;
                }
                this.Write(unaryExpression.Operand);
                return;
            }

            case ExpressionType.Equal:
                goto IL_D7;

            case ExpressionType.MemberAccess:
            {
                MemberExpression memberExpression = (MemberExpression)exp;
                if (!(memberExpression.Member is PropertyInfo))
                {
                    throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
                        {
                            this.m_condition.ToString()
                        }));
                }
                if (ConditionalExpressionToXmlConverter.IsClientResultValueExpression(memberExpression))
                {
                    this.Write(memberExpression.Expression);
                    return;
                }
                if (ConditionalExpressionToXmlConverter.IsServerObjectIsNullValue(memberExpression))
                {
                    this.Write(memberExpression.Expression);
                    return;
                }
                if (memberExpression.Expression != null)
                {
                    this.m_writer.WriteStartElement("ExpressionProperty");
                    this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(memberExpression.Member));
                    this.Write(memberExpression.Expression);
                    this.m_writer.WriteEndElement();
                    return;
                }
                this.m_writer.WriteStartElement("ExpressionStaticProperty");
                string serverTypeId2 = ConditionalExpressionToXmlConverter.GetServerTypeId(memberExpression.Member.DeclaringType);
                if (string.IsNullOrEmpty(serverTypeId2))
                {
                    throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
                        {
                            this.m_condition.ToString()
                        }));
                }
                this.m_writer.WriteAttributeString("TypeId", serverTypeId2);
                this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(memberExpression.Member));
                this.m_writer.WriteEndElement();
                return;
            }

            default:
                switch (nodeType)
                {
                case ExpressionType.Not:
                {
                    this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]);
                    UnaryExpression unaryExpression2 = (UnaryExpression)exp;
                    this.Write(unaryExpression2.Operand);
                    this.m_writer.WriteEndElement();
                    return;
                }

                case ExpressionType.NotEqual:
                    goto IL_D7;

                case ExpressionType.Or:
                    goto IL_71A;

                case ExpressionType.OrElse:
                    break;

                case ExpressionType.Parameter:
                {
                    ParameterExpression parameterExpression = (ParameterExpression)exp;
                    this.m_writer.WriteStartElement("ExpressionParameter");
                    this.m_writer.WriteAttributeString("Name", parameterExpression.Name);
                    this.m_writer.WriteEndElement();
                    return;
                }

                default:
                {
                    if (nodeType != ExpressionType.TypeIs)
                    {
                        goto IL_71A;
                    }
                    TypeBinaryExpression typeBinaryExpression = (TypeBinaryExpression)exp;
                    string value4 = null;
                    string value5 = null;
                    DataConvert.GetTypeNameOrTypeId(typeBinaryExpression.TypeOperand, out value4, out value5);
                    if (string.IsNullOrEmpty(value4) && string.IsNullOrEmpty(value5))
                    {
                        throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
                            {
                                this.m_condition.ToString()
                            }));
                    }
                    this.m_writer.WriteStartElement("ExpressionTypeIs");
                    if (!string.IsNullOrEmpty(value4))
                    {
                        this.m_writer.WriteAttributeString("Type", value4);
                    }
                    if (!string.IsNullOrEmpty(value5))
                    {
                        this.m_writer.WriteAttributeString("TypeId", value5);
                    }
                    this.Write(typeBinaryExpression.Expression);
                    this.m_writer.WriteEndElement();
                    return;
                }
                }
                break;
            }
            BinaryExpression binaryExpression = (BinaryExpression)exp;

            this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]);
            this.Write(binaryExpression.Left);
            this.Write(binaryExpression.Right);
            this.m_writer.WriteEndElement();
            return;

IL_D7:
            BinaryExpression binaryExpression2 = (BinaryExpression)exp;

            if (ConditionalExpressionToXmlConverter.IsNullExpression(binaryExpression2.Left) || ConditionalExpressionToXmlConverter.IsNullExpression(binaryExpression2.Right) || (ConditionalExpressionToXmlConverter.IsSupportedEqualType(binaryExpression2.Right.Type) && ConditionalExpressionToXmlConverter.IsSupportedEqualType(binaryExpression2.Left.Type)))
            {
                this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]);
                this.Write(binaryExpression2.Left);
                this.Write(binaryExpression2.Right);
                this.m_writer.WriteEndElement();
                return;
            }
            throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
            {
                this.m_condition.ToString()
            }));
IL_71A:
            throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[]
            {
                this.m_condition.ToString()
            }));
        }
Esempio n. 3
0
        public static void WriteValueToXmlElement(XmlWriter writer, object objValue, SerializationContext serializationContext)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            if (serializationContext == null)
            {
                throw new ArgumentNullException("serializationContext");
            }
            if (objValue == null)
            {
                writer.WriteAttributeString("Type", "Null");
                return;
            }
            if (!(objValue is ClientObject))
            {
                if (objValue is ClientValueObject)
                {
                    ClientValueObject clientValueObject = (ClientValueObject)objValue;
                    writer.WriteAttributeString("TypeId", clientValueObject.TypeId);
                    if (!clientValueObject.CustomWriteToXml(writer, serializationContext))
                    {
                        clientValueObject.WriteToXml(writer, serializationContext);
                        return;
                    }
                }
                else
                {
                    if (objValue is Stream)
                    {
                        Stream stream = (Stream)objValue;
                        writer.WriteAttributeString("Type", "Binary");
                        writer.WriteStartElement(MtomGlobals.XopIncludeLocalName);
                        string text = "http://sharepoint.microsoft.com/" + serializationContext.Context.NextSequenceId.ToString(CultureInfo.InvariantCulture);
                        serializationContext.AddStream(new StreamInfo(text, stream));
                        writer.WriteAttributeString(MtomGlobals.XopIncludeHrefLocalName, "cid:" + text);
                        writer.WriteEndElement();
                        return;
                    }
                    DataConvert.WriteValueHandler writeValueHandler = null;
                    if (DataConvert.s_writeValueHandlers.TryGetValue(objValue.GetType(), out writeValueHandler))
                    {
                        writer.WriteAttributeString("Type", DataConvert.s_writeValueTypeNames[objValue.GetType()]);
                        writeValueHandler(writer, objValue);
                        return;
                    }
                    if (objValue.GetType().IsArray)
                    {
                        writer.WriteAttributeString("Type", "Array");
                        //Edited for .NET Core
                        //using (IEnumerator enumerator = ((Array)objValue).GetEnumerator())
                        IEnumerator enumerator = ((Array)objValue).GetEnumerator();
                        {
                            while (enumerator.MoveNext())
                            {
                                object current = enumerator.Current;
                                writer.WriteStartElement("Object");
                                DataConvert.WriteValueToXmlElement(writer, current, serializationContext);
                                writer.WriteEndElement();
                            }
                            return;
                        }
                    }
                    if (objValue is IDictionary)
                    {
                        writer.WriteAttributeString("Type", "Dictionary");
                        IDictionary           dictionary  = objValue as IDictionary;
                        IDictionaryEnumerator enumerator2 = dictionary.GetEnumerator();
                        while (enumerator2.MoveNext())
                        {
                            object value = enumerator2.Value;
                            if (DataConvert.CouldSerializeDictionaryEntry(value) && enumerator2.Key is string)
                            {
                                writer.WriteStartElement("Property");
                                writer.WriteAttributeString("Name", (string)enumerator2.Key);
                                DataConvert.WriteValueToXmlElement(writer, enumerator2.Value, serializationContext);
                                writer.WriteEndElement();
                            }
                        }
                        return;
                    }
                    //Edited for .NET Core
                    //if (typeof(IEnumerable).IsAssignableFrom(objValue.GetType()) && ExpressionUtility.GetElementType(objValue.GetType()) != null)

                    if (typeof(IEnumerable).GetTypeInfo().IsAssignableFrom(objValue.GetType()) && ExpressionUtility.GetElementType(objValue.GetType()) != null)
                    {
                        writer.WriteAttributeString("Type", "Array");
                        //Edited for .NET Core
                        //using (IEnumerator enumerator3 = ((IEnumerable)objValue).GetEnumerator())
                        IEnumerator enumerator3 = ((IEnumerable)objValue).GetEnumerator();
                        {
                            while (enumerator3.MoveNext())
                            {
                                object current2 = enumerator3.Current;
                                writer.WriteStartElement("Object");
                                DataConvert.WriteValueToXmlElement(writer, current2, serializationContext);
                                writer.WriteEndElement();
                            }
                            return;
                        }
                    }
                    Type type = objValue.GetType();
                    //Edited for .NET Core
                    //if (type.IsEnum)
                    if (type.GetTypeInfo().IsEnum)
                    {
                        writer.WriteAttributeString("Type", "Enum");
                        DataConvert.s_writeValueEnum(writer, objValue);
                        return;
                    }
                    writer.WriteAttributeString("Type", "Unspecified");
                    writer.WriteString(objValue.ToString());
                }
                return;
            }
            ClientObject clientObject = (ClientObject)objValue;

            if (clientObject.Path == null)
            {
                throw new ClientRequestException(Resources.GetString("NoObjectPathAssociatedWithObject"));
            }
            ClientAction.CheckActionParameterInContext(serializationContext.Context, clientObject);
            writer.WriteAttributeString("ObjectPathId", clientObject.Path.Id.ToString(CultureInfo.InvariantCulture));
            serializationContext.AddClientObject(clientObject);
        }
        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);
        }