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);
}