internal QueryOperationResponse <TElement> Execute <TElement>(DataServiceContext context, System.Data.Services.Client.QueryComponents queryComponents)
{
QueryResult result = null;
QueryOperationResponse <TElement> response2;
try
{
result = new DataServiceRequest <TElement>(queryComponents, this.Plan).CreateResult(this, context, null, null, "Execute");
result.ExecuteQuery(context);
response2 = result.ProcessResult <TElement>(this.Plan);
}
catch (InvalidOperationException exception)
{
if (result != null)
{
QueryOperationResponse response = result.GetResponse <TElement>(MaterializeAtom.EmptyResults);
if (response != null)
{
if (context.IgnoreResourceNotFoundException)
{
DataServiceClientException exception2 = exception as DataServiceClientException;
if ((exception2 != null) && (exception2.StatusCode == 0x194))
{
return((QueryOperationResponse <TElement>)response);
}
}
response.Error = exception;
throw new DataServiceQueryException(System.Data.Services.Client.Strings.DataServiceException_GeneralError, exception, response);
}
}
throw;
}
return(response2);
}
internal QueryResult(object source, string method, DataServiceRequest serviceRequest, ODataRequestMessageWrapper request, System.Data.Services.Client.RequestInfo requestInfo, AsyncCallback callback, object state) : base(source, method, callback, state)
{
this.ServiceRequest = serviceRequest;
this.Request = request;
this.RequestInfo = requestInfo;
base.Abortable = request;
}
internal QueryOperationResponse<TElement> Execute<TElement>(DataServiceContext context, QueryComponents queryComponents)
{
QueryResult result = null;
try
{
DataServiceRequest<TElement> serviceRequest = new DataServiceRequest<TElement>(queryComponents, this.Plan);
result = serviceRequest.CreateResult(this, context, null, null);
result.Execute();
return result.ProcessResult<TElement>(context, this.Plan);
}
catch (InvalidOperationException ex)
{
QueryOperationResponse operationResponse = result.GetResponse<TElement>(MaterializeAtom.EmptyResults);
if (null != operationResponse)
{
if (context.IgnoreResourceNotFoundException)
{
DataServiceClientException cex = ex as DataServiceClientException;
if (cex != null && cex.StatusCode == (int)HttpStatusCode.NotFound)
{
return (QueryOperationResponse<TElement>)operationResponse;
}
}
operationResponse.Error = ex;
throw new DataServiceQueryException(Strings.DataServiceException_GeneralError, ex, operationResponse);
}
throw;
}
}
internal QueryResult(object source, string method, DataServiceRequest serviceRequest, HttpWebRequest request, AsyncCallback callback, object state)
: base(source, method, callback, state)
{
Debug.Assert(null != request, "null request");
this.ServiceRequest = serviceRequest;
this.Request = request;
this.Abortable = request;
}
/// <summary>constructor</summary>
/// <param name="source">source object of async request</param>
/// <param name="method">async method name on source object</param>
/// <param name="serviceRequest">Originating serviceRequest</param>
/// <param name="request">Originating WebRequest</param>
/// <param name="requestInfo">The request info of the originating request.</param>
/// <param name="callback">user callback</param>
/// <param name="state">user state</param>
internal QueryResult(object source, string method, DataServiceRequest serviceRequest, ODataRequestMessageWrapper request, RequestInfo requestInfo, AsyncCallback callback, object state)
: base(source, method, callback, state)
{
Debug.Assert(null != request, "null request");
this.ServiceRequest = serviceRequest;
this.Request = request;
this.RequestInfo = requestInfo;
this.Abortable = request;
}
internal long GetQuerySetCount(DataServiceContext context)
{
long num2;
Version requestVersion = this.QueryComponents(context.MaxProtocolVersion).Version;
if ((requestVersion == null) || (requestVersion.Major < 2))
{
requestVersion = Util.DataServiceVersion2;
}
QueryResult result = null;
DataServiceRequest <long> serviceRequest = new DataServiceRequest <long>(this.QueryComponents(context.MaxProtocolVersion), null);
KeyValuePair <string, string>[] pairArray = new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("Accept", "text/plain") };
IEnumerable <KeyValuePair <string, string> > headers = pairArray;
ODataRequestMessageWrapper request = context.CreateODataRequestMessage("GET", this.QueryComponents(context.MaxProtocolVersion).Uri, false, requestVersion, headers, new string[] { "Accept" });
result = new QueryResult(this, "Execute", serviceRequest, request, new RequestInfo(context), null, null);
try
{
result.ExecuteQuery(context);
if (HttpStatusCode.NoContent == result.StatusCode)
{
throw new DataServiceQueryException(System.Data.Services.Client.Strings.DataServiceRequest_FailGetCount, result.Failure);
}
StreamReader reader = new StreamReader(result.GetResponseStream());
long num = -1L;
try
{
num = XmlConvert.ToInt64(reader.ReadToEnd());
}
finally
{
reader.Close();
}
num2 = num;
}
catch (InvalidOperationException exception)
{
QueryOperationResponse response = null;
response = result.GetResponse <long>(MaterializeAtom.EmptyResults);
if (response != null)
{
response.Error = exception;
throw new DataServiceQueryException(System.Data.Services.Client.Strings.DataServiceException_GeneralError, exception, response);
}
throw;
}
return(num2);
}
internal long GetQuerySetCount(DataServiceContext context)
{
Debug.Assert(null != context, "context is null");
this.QueryComponents.Version = Util.DataServiceVersion2;
QueryResult response = null;
DataServiceRequest<long> serviceRequest = new DataServiceRequest<long>(this.QueryComponents, null);
HttpWebRequest request = context.CreateRequest(this.QueryComponents.Uri, XmlConstants.HttpMethodGet, false, null, this.QueryComponents.Version, false);
request.Accept = "text/plain";
response = new QueryResult(this, "Execute", serviceRequest, request, null, null);
try
{
response.Execute();
if (HttpStatusCode.NoContent != response.StatusCode)
{
StreamReader sr = new StreamReader(response.GetResponseStream());
long r = -1;
try
{
r = XmlConvert.ToInt64(sr.ReadToEnd());
}
finally
{
sr.Close();
}
return r;
}
else
{
throw new DataServiceQueryException(Strings.DataServiceRequest_FailGetCount, response.Failure);
}
}
catch (InvalidOperationException ex)
{
QueryOperationResponse operationResponse = null;
operationResponse = response.GetResponse<long>(MaterializeAtom.EmptyResults);
if (null != operationResponse)
{
operationResponse.Error = ex;
throw new DataServiceQueryException(Strings.DataServiceException_GeneralError, ex, operationResponse);
}
throw;
}
}
internal MaterializeAtom GetMaterializer(DataServiceContext context, ProjectionPlan plan)
{
Debug.Assert(this.IsCompletedInternally, "request hasn't completed yet");
MaterializeAtom materializer;
if (HttpStatusCode.NoContent != this.StatusCode)
{
materializer = DataServiceRequest.Materialize(context, this.ServiceRequest.QueryComponents, plan, this.ContentType, this.GetResponseStream());
}
else
{
materializer = MaterializeAtom.EmptyResults;
}
return(materializer);
}
/// <summary>
/// execute uri and materialize result
/// </summary>
/// <typeparam name="TElement">element type</typeparam>
/// <param name="context">context</param>
/// <param name="queryComponents">query components for request to execute</param>
/// <returns>enumerable of results</returns>
internal QueryOperationResponse <TElement> Execute <TElement>(DataServiceContext context, QueryComponents queryComponents)
{
QueryResult result = null;
try
{
Uri requestUri = queryComponents.Uri;
DataServiceRequest <TElement> serviceRequest = new DataServiceRequest <TElement>(requestUri, queryComponents, this.Plan);
result = serviceRequest.CreateExecuteResult(this, context, null, null, Util.ExecuteMethodName);
result.AllowDirectNetworkStreamReading = context.AllowDirectNetworkStreamReading;
result.ExecuteQuery();
return(result.ProcessResult <TElement>(this.Plan));
}
catch (InvalidOperationException ex)
{
if (result != null)
{
QueryOperationResponse operationResponse = result.GetResponse <TElement>(MaterializeAtom.EmptyResults);
if (null != operationResponse)
{
if (context.IgnoreResourceNotFoundException)
{
DataServiceClientException cex = ex as DataServiceClientException;
if (cex != null && cex.StatusCode == (int)HttpStatusCode.NotFound)
{
// don't throw
return((QueryOperationResponse <TElement>)operationResponse);
}
}
operationResponse.Error = ex;
throw new DataServiceQueryException(Strings.DataServiceException_GeneralError, ex, operationResponse);
}
}
throw;
}
}
/// <summary>
/// Creates an instance of <see cref="MaterializeAtom"/> for the given plan.
/// </summary>
/// <param name="plan">The projection plan.</param>
/// <param name="payloadKind">expected payload kind.</param>
/// <returns>A new materializer instance</returns>
private MaterializeAtom CreateMaterializer(ProjectionPlan plan, ODataPayloadKind payloadKind)
{
QueryComponents queryComponents = this.ServiceRequest.QueryComponents(this.responseInfo.Model);
// In V2, in projection path, we did not check for assignability between the expected type and the type returned by the type resolver.
if (plan != null || queryComponents.Projection != null)
{
this.RequestInfo.TypeResolver.IsProjectionRequest();
}
var responseMessageWrapper = new HttpWebResponseMessage(
new HeaderCollection(this.responseMessage),
this.responseMessage.StatusCode,
this.GetResponseStream,
this.AllowDirectNetworkStreamReading ? this.responseMessage : null); // If AllowDirectNetworkStreamReading is true, the responseMessage will be disposed later when enumeration has finished.
return DataServiceRequest.Materialize(
this.responseInfo,
queryComponents,
plan,
this.ContentType,
responseMessageWrapper,
payloadKind);
}
/// <summary>constructor</summary>
/// <param name="entity">entity</param>
/// <param name="propertyName">name of collection or reference property to load</param>
/// <param name="context">Originating context</param>
/// <param name="request">Originating WebRequest</param>
/// <param name="callback">user callback</param>
/// <param name="state">user state</param>
/// <param name="dataServiceRequest">request object.</param>
/// <param name="plan">Projection plan for materialization; possibly null.</param>
/// <param name="isContinuation">Whether this request is a continuation request.</param>
internal LoadPropertyResult(object entity, string propertyName, DataServiceContext context, ODataRequestMessageWrapper request, AsyncCallback callback, object state, DataServiceRequest dataServiceRequest, ProjectionPlan plan, bool isContinuation)
: base(context, Util.LoadPropertyMethodName, dataServiceRequest, request, new RequestInfo(context, isContinuation), callback, state)
{
this.entity = entity;
this.propertyName = propertyName;
this.plan = plan;
}
internal static QueryOperationResponse GetInstance(Type elementType, Dictionary <string, string> headers, DataServiceRequest query, MaterializeAtom results)
{
return((QueryOperationResponse)Activator.CreateInstance(typeof(QueryOperationResponse <>).MakeGenericType(new Type[] { elementType }), BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { headers, query, results }, CultureInfo.InvariantCulture));
}
/// <summary>constructor</summary>
/// <param name="source">source object of async request</param>
/// <param name="method">async method name on source object</param>
/// <param name="serviceRequest">Originating serviceRequest</param>
/// <param name="request">Originating WebRequest</param>
/// <param name="requestInfo">The request info of the originating request.</param>
/// <param name="callback">user callback</param>
/// <param name="state">user state</param>
/// <param name="requestContentStream">the stream containing the request data.</param>
internal QueryResult(object source, string method, DataServiceRequest serviceRequest, ODataRequestMessageWrapper request, RequestInfo requestInfo, AsyncCallback callback, object state, ContentStream requestContentStream)
: this(source, method, serviceRequest, request, requestInfo, callback, state)
{
Debug.Assert(null != requestContentStream, "null requestContentStream");
this.requestContentStream = requestContentStream;
}
internal static QueryOperationResponse GetInstance(Type elementType, Dictionary <string, string> headers, DataServiceRequest query, MaterializeAtom results)
{
Type genericType = typeof(QueryOperationResponse <>).MakeGenericType(elementType);
#if !ASTORIA_LIGHT
return((QueryOperationResponse)Activator.CreateInstance(
genericType,
BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Instance,
null,
new object[] { headers, query, results },
System.Globalization.CultureInfo.InvariantCulture));
#else
System.Reflection.ConstructorInfo[] info = genericType.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
System.Diagnostics.Debug.Assert(1 == info.Length, "only expected 1 ctor");
return((QueryOperationResponse)Util.ConstructorInvoke(info[0], new object[] { headers, query, results }));
#endif
}
internal QueryOperationResponse(Dictionary <string, string> headers, DataServiceRequest query, MaterializeAtom results)
: base(headers)
{
this.query = query;
this.results = results;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="headers">HTTP headers</param>
/// <param name="query">original query</param>
/// <param name="results">retrieved objects</param>
internal QueryOperationResponse(HeaderCollection headers, DataServiceRequest query, MaterializeAtom results)
: base(headers, query, results)
{
}
/// <summary>
/// Synchronizely get the query set count from the server by executing the $count=value query
/// </summary>
/// <param name="context">The context</param>
/// <returns>The server side count of the query set</returns>
internal long GetQuerySetCount(DataServiceContext context)
{
Debug.Assert(null != context, "context is null");
Version requestVersion = this.QueryComponents(context.Model).Version;
if (requestVersion == null || requestVersion.Major < 2)
{
// minimum DSV for $count is V2.
requestVersion = Util.DataServiceVersion2;
}
QueryResult response = null;
QueryComponents qc = this.QueryComponents(context.Model);
Uri requestUri = qc.Uri;
DataServiceRequest <long> serviceRequest = new DataServiceRequest <long>(requestUri, qc, null);
HeaderCollection headers = new HeaderCollection();
// Validate and set the request DSV header
headers.SetRequestVersion(requestVersion, context.MaxProtocolVersionAsVersion);
context.Format.SetRequestAcceptHeaderForCount(headers);
string httpMethod = XmlConstants.HttpMethodGet;
ODataRequestMessageWrapper request = context.CreateODataRequestMessage(
context.CreateRequestArgsAndFireBuildingRequest(httpMethod, requestUri, headers, context.HttpStack, null /*descriptor*/),
new string[] { XmlConstants.HttpRequestAccept } /*headersToReset*/,
null /*descriptor*/);
response = new QueryResult(this, Util.ExecuteMethodName, serviceRequest, request, new RequestInfo(context), null, null);
response.AllowDirectNetworkStreamReading = context.AllowDirectNetworkStreamReading;
IODataResponseMessage responseMessage = null;
try
{
responseMessage = response.ExecuteQuery();
if (HttpStatusCode.NoContent != response.StatusCode)
{
StreamReader sr = new StreamReader(response.GetResponseStream());
long r = -1;
try
{
r = XmlConvert.ToInt64(sr.ReadToEnd());
}
finally
{
sr.Close();
}
return(r);
}
else
{
throw new DataServiceQueryException(Strings.DataServiceRequest_FailGetCount, response.Failure);
}
}
catch (InvalidOperationException ex)
{
QueryOperationResponse operationResponse = null;
operationResponse = response.GetResponse <long>(MaterializeAtom.EmptyResults);
if (null != operationResponse)
{
operationResponse.Error = ex;
throw new DataServiceQueryException(Strings.DataServiceException_GeneralError, ex, operationResponse);
}
throw;
}
finally
{
WebUtil.DisposeMessage(responseMessage);
}
}
internal QueryResult(object source, string method, DataServiceRequest serviceRequest, ODataRequestMessageWrapper request, System.Data.Services.Client.RequestInfo requestInfo, AsyncCallback callback, object state, BaseAsyncResult.ContentStream requestContentStream) : this(source, method, serviceRequest, request, requestInfo, callback, state)
{
this.requestContentStream = requestContentStream;
}
internal QueryOperationResponse <TElement> ProcessResult <TElement>(DataServiceContext context, ProjectionPlan plan)
{
MaterializeAtom materializeAtom = DataServiceRequest.Materialize(context, this.ServiceRequest.QueryComponents, plan, this.ContentType, this.GetResponseStream());
return(this.GetResponse <TElement>(materializeAtom));
}
/// <summary>
/// constructor
/// </summary>
/// <param name="headers">HTTP headers</param>
/// <param name="query">original query</param>
/// <param name="results">retrieved objects</param>
internal QueryOperationResponse(HeaderCollection headers, DataServiceRequest query, MaterializeAtom results)
: base(headers)
{
this.query = query;
this.results = results;
}
private IEnumerable <OperationResponse> HandleBatchResponse(ODataBatchReader batchReader)
{
if (this.batchMessageReader == null)
{
goto Label_056D;
}
bool iteratorVariable0 = false;
bool iteratorVariable1 = false;
int index = 0;
int iteratorVariable3 = 0;
this.entryIndex = 0;
Label_PostSwitchInIterator :;
while (batchReader.Read())
{
Exception iteratorVariable4;
switch (batchReader.State)
{
case ODataBatchReaderState.Operation:
{
iteratorVariable4 = this.ProcessCurrentOperationResponse(batchReader);
if (iteratorVariable1)
{
break;
}
QueryOperationResponse iteratorVariable5 = null;
try
{
if (iteratorVariable4 == null)
{
DataServiceRequest query = this.Queries[index];
MaterializeAtom results = DataServiceRequest.Materialize(this.RequestInfo.GetDeserializationInfo(null), query.QueryComponents(this.RequestInfo.MaxProtocolVersion), null, this.currentOperationResponse.GetHeader("Content-Type"), this.currentOperationResponse.CreateResponseMessage(), query.PayloadKind);
iteratorVariable5 = QueryOperationResponse.GetInstance(query.ElementType, this.currentOperationResponse.Headers, query, results);
}
}
catch (ArgumentException exception)
{
iteratorVariable4 = exception;
}
catch (FormatException exception2)
{
iteratorVariable4 = exception2;
}
catch (InvalidOperationException exception3)
{
iteratorVariable4 = exception3;
}
if (iteratorVariable5 == null)
{
if (this.Queries == null)
{
throw iteratorVariable4;
}
DataServiceRequest request2 = this.Queries[index];
if (this.RequestInfo.IgnoreResourceNotFoundException && (this.currentOperationResponse.StatusCode == HttpStatusCode.NotFound))
{
iteratorVariable5 = QueryOperationResponse.GetInstance(request2.ElementType, this.currentOperationResponse.Headers, request2, MaterializeAtom.EmptyResults);
}
else
{
iteratorVariable5 = QueryOperationResponse.GetInstance(request2.ElementType, this.currentOperationResponse.Headers, request2, MaterializeAtom.EmptyResults);
iteratorVariable5.Error = iteratorVariable4;
}
}
iteratorVariable5.StatusCode = (int)this.currentOperationResponse.StatusCode;
index++;
yield return(iteratorVariable5);
goto Label_PostSwitchInIterator;
}
case ODataBatchReaderState.ChangesetStart:
{
if ((this.IsBatch && iteratorVariable0) || (iteratorVariable3 != 0))
{
System.Data.Services.Client.Error.ThrowBatchUnexpectedContent(InternalError.UnexpectedBeginChangeSet);
}
iteratorVariable1 = true;
continue;
}
case ODataBatchReaderState.ChangesetEnd:
{
iteratorVariable0 = true;
iteratorVariable3 = 0;
iteratorVariable1 = false;
continue;
}
default:
goto Label_0491;
}
this.entryIndex = this.ValidateContentID(this.currentOperationResponse.Headers);
try
{
Descriptor descriptor = this.ChangedEntries[this.entryIndex];
iteratorVariable3 += this.SaveResultProcessed(descriptor);
if (iteratorVariable4 != null)
{
throw iteratorVariable4;
}
this.HandleOperationResponseHeaders(this.currentOperationResponse.StatusCode, this.currentOperationResponse.Headers);
this.HandleOperationResponse(descriptor, this.currentOperationResponse.Headers);
}
catch (Exception exception4)
{
this.ChangedEntries[this.entryIndex].SaveError = exception4;
iteratorVariable4 = exception4;
if (!CommonUtil.IsCatchableExceptionType(exception4))
{
throw;
}
}
ChangeOperationResponse iteratorVariable6 = new ChangeOperationResponse(this.currentOperationResponse.Headers, this.ChangedEntries[this.entryIndex])
{
StatusCode = (int)this.currentOperationResponse.StatusCode
};
if (iteratorVariable4 != null)
{
iteratorVariable6.Error = iteratorVariable4;
}
iteratorVariable3++;
this.entryIndex++;
yield return(iteratorVariable6);
goto Label_PostSwitchInIterator;
Label_0491:
System.Data.Services.Client.Error.ThrowBatchExpectedResponse(InternalError.UnexpectedBatchState);
}
if (((this.Queries == null) && ((!iteratorVariable0 || (0 < index)) || (this.ChangedEntries.Any <Descriptor>(o => (o.ContentGeneratedForSave && (o.SaveResultWasProcessed == 0))) && (!this.IsBatch || (this.ChangedEntries.FirstOrDefault <Descriptor>(o => (o.SaveError != null)) == null))))) || ((this.Queries != null) && (index != this.Queries.Length)))
{
throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Batch_IncompleteResponseCount);
}
Label_056D:
yield break;
}
public IEnumerable <TElement> EndExecute(IAsyncResult asyncResult)
{
return(DataServiceRequest.EndExecute <TElement>(this, this.queryProvider.Context, "Execute", asyncResult));
}
/// <summary>Ends an asynchronous query request to a data service.</summary>
/// <returns>Returns an <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains the results of the query operation.</returns>
/// <param name="asyncResult">The pending asynchronous query request.</param>
/// <exception cref="T:System.Data.Services.Client.DataServiceQueryException">When the data service returns an HTTP 404: Resource Not Found error.</exception>
public new IEnumerable <TElement> EndExecute(IAsyncResult asyncResult)
{
return(DataServiceRequest.EndExecute <TElement>(this, this.Context, Util.ExecuteMethodName, asyncResult));
}
internal static QueryOperationResponse GetInstance(Type elementType, HeaderCollection headers, DataServiceRequest query, MaterializeAtom results)
{
Type genericType = typeof(QueryOperationResponse <>).MakeGenericType(elementType);
#if !ASTORIA_LIGHT && !PORTABLELIB
return((QueryOperationResponse)Activator.CreateInstance(
genericType,
BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Instance,
null,
new object[] { headers, query, results },
System.Globalization.CultureInfo.InvariantCulture));
#else
ConstructorInfo info = genericType.GetInstanceConstructors(false /*isPublic*/).Single();
return((QueryOperationResponse)Util.ConstructorInvoke(info, new object[] { headers, query, results }));
#endif
}
private MaterializeAtom CreateMaterializer(ProjectionPlan plan, ODataPayloadKind payloadKind)
{
HttpWebResponseMessage message = new HttpWebResponseMessage(this.httpWebResponse, () => this.GetResponseStream());
return(DataServiceRequest.Materialize(this.responseInfo, this.ServiceRequest.QueryComponents(this.responseInfo.MaxProtocolVersion), plan, this.ContentType, message, payloadKind));
}
