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 void ProcessResponseStream(Stream responseStream) { StreamReader reader = new StreamReader(responseStream, Encoding.UTF8); JsonReader jsonReader = new JsonReader(reader, this.m_context); jsonReader.ReadArrayStart(); Dictionary<string, object> dictionary = jsonReader.ReadObject() as Dictionary<string, object>; if (dictionary == null) { throw new ClientRequestException(Resources.GetString("RequestUnknownResponse")); } object obj; if (!dictionary.TryGetValue("SchemaVersion", out obj)) { throw new ClientRequestException(Resources.GetString("RequestUnknownResponse")); } string text = obj as string; if (string.IsNullOrEmpty(text)) { throw new ClientRequestException(Resources.GetString("RequestUnknownResponse")); } this.m_context.ServerSchemaVersion = new Version(text); if (!dictionary.TryGetValue("LibraryVersion", out obj)) { throw new ClientRequestException(Resources.GetString("RequestUnknownResponse")); } string text2 = obj as string; if (string.IsNullOrEmpty(text2)) { throw new ClientRequestException(Resources.GetString("RequestUnknownResponse")); } this.m_context.ServerLibraryVersion = new Version(text2); if (dictionary.TryGetValue("TraceCorrelationId", out obj)) { this.m_context.SetTraceCorrelationId(obj as string); } if (!dictionary.TryGetValue("ErrorInfo", out obj)) { throw new ClientRequestException(Resources.GetString("RequestUnknownResponse")); } object obj2 = obj; if (obj2 != null) { Dictionary<string, object> dictionary2 = obj2 as Dictionary<string, object>; if (dictionary2 == null) { throw new ClientRequestException(Resources.GetString("RequestUnknownResponse")); } ServerException ex = ServerException.CreateFromErrorInfo(dictionary2); throw ex; } else { if (!ClientRuntimeContext.CanHandleResponseSchema(this.m_context.ServerSchemaVersion)) { throw new ClientRequestException(Resources.GetString("CannotHandleServerResponseSchema", new object[] { text })); } while (jsonReader.PeekTokenType() != JsonTokenType.ArrayEnd) { long num = jsonReader.ReadInt64(); obj = null; if (this.m_queryIdToObjectMap.TryGetValue(num.ToString(CultureInfo.InvariantCulture), out obj) && obj != null) { ClientObject clientObject = obj as ClientObject; string scriptType = null; if (clientObject != null && jsonReader.PeekTokenType() == JsonTokenType.ObjectStart && jsonReader.PeekObjectType(out scriptType)) { Type typeFromScriptType = ScriptTypeMap.GetTypeFromScriptType(scriptType); if (typeFromScriptType != null && typeFromScriptType != clientObject.GetType()) { ClientObject clientObject2 = ScriptTypeMap.CreateObjectFromScriptType(scriptType, this.Context) as ClientObject; if (clientObject2 != null) { clientObject.SetTypedObject(clientObject2); obj = clientObject2; } } } IFromJson fromJson = obj as IFromJson; if (fromJson != null && !fromJson.CustomFromJson(jsonReader)) { fromJson.FromJson(jsonReader); } } else { jsonReader.ReadObject(); } } return; } }
internal void AddObjectToQueryCleanupList(ClientObject obj) { this.PendingRequest.AddObjectToQueryCleanupList(obj); }
internal void SetObjectDataFrom(ClientObject otherObject) { this.m_objectData = otherObject.m_objectData; }
public T CastTo <T>(ClientObject obj) where T : ClientObject { if (obj == null) { throw new ArgumentNullException("obj"); } ClientAction.CheckActionParameterInContext(this, obj); Type typeFromHandle = typeof(T); //Edited for .NET Core //if (!typeof(ClientObject).IsAssignableFrom(typeFromHandle)) if (!typeof(ClientObject).GetTypeInfo().IsAssignableFrom(typeFromHandle)) { throw new ArgumentException(); } if (obj.Context != this) { throw new InvalidOperationException(); } T t; //Edited for .NET Core //if (typeFromHandle.IsAssignableFrom(obj.GetType())) if (typeFromHandle.GetTypeInfo().IsAssignableFrom(obj.GetType())) { t = (T)((object)Activator.CreateInstance(typeFromHandle, new object[] { this, obj.Path })); t.SetObjectDataFrom(obj); return(t); } //Edited for .NET Core //if (obj.ObjectData.AssociatedObject != null && typeFromHandle.IsAssignableFrom(obj.ObjectData.AssociatedObject.GetType())) if (obj.ObjectData.AssociatedObject != null && typeFromHandle.GetTypeInfo().IsAssignableFrom(obj.ObjectData.AssociatedObject.GetType())) { t = (T)((object)Activator.CreateInstance(typeFromHandle, new object[] { this, obj.Path })); t.SetObjectDataFrom(obj); return(t); } //Edited for .NET Core //if (!obj.GetType().IsAssignableFrom(typeFromHandle)) if (!obj.GetType().GetTypeInfo().IsAssignableFrom(typeFromHandle)) { throw ClientUtility.CreateArgumentException("type"); } //Edited for .NET Core //if (obj.ObjectData.AssociatedObject != null && !obj.ObjectData.AssociatedObject.GetType().IsAssignableFrom(typeFromHandle)) if (obj.ObjectData.AssociatedObject != null && !obj.ObjectData.AssociatedObject.GetType().GetTypeInfo().IsAssignableFrom(typeFromHandle)) { throw ClientUtility.CreateArgumentException("type"); } t = (T)((object)Activator.CreateInstance(typeFromHandle, new object[] { this, obj.Path })); t.SetObjectDataFrom(obj); object obj2; if (obj.ObjectData.AssociatedObject == null) { obj2 = obj; } else { obj2 = obj.ObjectData.AssociatedObject; } if (obj2 != null) { List <string> list = new List <string>(); Dictionary <string, object> queryIdToObjectMap = this.PendingRequest.QueryIdToObjectMap; foreach (KeyValuePair <string, object> current in queryIdToObjectMap) { if (object.ReferenceEquals(current.Value, obj2)) { list.Add(current.Key); } } foreach (string current2 in list) { queryIdToObjectMap[current2] = t; } obj.ObjectData.AssociatedObject = t; } return(t); }
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); }
private static ClientQueryInternal ProcessMemberAccessQueryExpression(ClientQueryInternal rootQuery, ClientObject rootClientObject, MemberExpression exp, bool leaf, DataRetrieval.QueryProcessInfo queryInfo, DataRetrieval.QueryMethodAggregator aggregator) { //Edited for .NET Core //if (exp.Member.MemberType != MemberTypes.Property || exp.Member.GetCustomAttributes(typeof(RemoteAttribute), false).Length <= 0) if (exp.Member.MemberType != MemberTypes.Property || exp.Member.GetCustomAttributes(typeof(RemoteAttribute), false).Count() <= 0) { throw DataRetrieval.CreateInvalidQueryExpressionException(exp); } ClientQueryInternal clientQueryInternal = DataRetrieval.ProcessQueryExpression(rootQuery, rootClientObject, exp.Expression, false, queryInfo, aggregator); aggregator.Member++; if (clientQueryInternal == null) { throw new InvalidQueryExpressionException(); } ClientQueryInternal clientQueryInternal2; //if (typeof(ClientObject).IsAssignableFrom(exp.Type)) if (typeof(ClientObject).GetTypeInfo().IsAssignableFrom(exp.Type)) { clientQueryInternal2 = clientQueryInternal.GetSubQuery(exp.Member.Name); if (clientQueryInternal2 == null) { clientQueryInternal2 = new ClientQueryInternal(null, exp.Member.Name, true, clientQueryInternal); clientQueryInternal.SelectSubQuery(clientQueryInternal2); } if (leaf) { clientQueryInternal.SelectWithAll(exp.Member.Name); } } else { clientQueryInternal.Select(exp.Member.Name); clientQueryInternal2 = null; } return(clientQueryInternal2); }
private static ClientQueryInternal ProcessQueryExpression(ClientQueryInternal rootQuery, ClientObject rootClientObject, Expression exp, bool leaf, DataRetrieval.QueryProcessInfo queryInfo, DataRetrieval.QueryMethodAggregator aggregator) { ExpressionType nodeType = exp.NodeType; switch (nodeType) { case ExpressionType.Call: { ClientQueryInternal result = DataRetrieval.ProcessMethodCallQueryExpression(rootQuery, rootClientObject, (MethodCallExpression)exp, leaf, queryInfo, aggregator); return(result); } case ExpressionType.Coalesce: case ExpressionType.Conditional: break; case ExpressionType.Constant: { ConstantExpression constantExpression = (ConstantExpression)exp; if (constantExpression.Value == rootClientObject) { ClientQueryInternal result = rootQuery; return(result); } throw DataRetrieval.CreateInvalidQueryExpressionException(exp); } case ExpressionType.Convert: case ExpressionType.ConvertChecked: { UnaryExpression unaryExpression = (UnaryExpression)exp; ClientQueryInternal result = DataRetrieval.ProcessQueryExpression(rootQuery, rootClientObject, unaryExpression.Operand, leaf, queryInfo, aggregator); return(result); } default: if (nodeType == ExpressionType.MemberAccess) { ClientQueryInternal result = DataRetrieval.ProcessMemberAccessQueryExpression(rootQuery, rootClientObject, (MemberExpression)exp, leaf, queryInfo, aggregator); return(result); } if (nodeType == ExpressionType.Parameter) { ClientQueryInternal result = rootQuery; return(result); } break; } throw DataRetrieval.CreateInvalidQueryExpressionException(exp); }