private static bool ShouldIgnoreNode(XmlReader reader)
{
Debug.Assert(reader != null, "reader != null");
switch (reader.NodeType)
{
case XmlNodeType.CDATA:
case XmlNodeType.EntityReference:
case XmlNodeType.EndEntity:
Error.ThrowInternalError(InternalError.UnexpectedXmlNodeTypeWhenReading);
break;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
Error.ThrowInternalError(InternalError.UnexpectedXmlNodeTypeWhenReading);
break;
case XmlNodeType.Element:
case XmlNodeType.EndElement:
return(false);
default:
break;
}
return(true);
}
private static void CompleteCheck(QueryResult pereq, InternalError errorcode)
{
if ((null == pereq) || (pereq.IsCompletedInternally && !pereq.IsAborted))
{
Error.ThrowInternalError(errorcode);
}
}
protected static void EqualRefCheck(PerRequest actual, PerRequest expected, InternalError errorcode)
{
if (!object.ReferenceEquals(actual, expected))
{
Error.ThrowInternalError(errorcode);
}
}
protected virtual void CompleteCheck(PerRequest value, InternalError errorcode)
{
if ((value == null) || value.RequestCompleted)
{
Error.ThrowInternalError(errorcode);
}
}
/// <summary>
/// Checks whether the current node on the specified <paramref name="reader"/>
/// should be ignored.
/// </summary>
/// <param name="reader">Reader to check.</param>
/// <returns>true if the node should be ignored; false if it should be processed.</returns>
/// <remarks>
/// This method will throw an exception on unexpected content (CDATA, entity references,
/// text); therefore it should not be used if mixed content is allowed.
/// </remarks>
private static bool ShouldIgnoreNode(XmlReader reader)
{
Debug.Assert(reader != null, "reader != null");
switch (reader.NodeType)
{
case XmlNodeType.CDATA:
case XmlNodeType.EntityReference:
case XmlNodeType.EndEntity:
Error.ThrowInternalError(InternalError.UnexpectedXmlNodeTypeWhenReading);
break;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
// throw Error.InvalidOperation(Strings.Deserialize_MixedContent(currentType.ElementTypeName));
Error.ThrowInternalError(InternalError.UnexpectedXmlNodeTypeWhenReading);
break;
case XmlNodeType.Element:
case XmlNodeType.EndElement:
return(false);
default:
break;
}
return(true);
}
internal static T NullCheck <T>(T value, InternalError errorcode) where T : class
{
if (object.ReferenceEquals(value, null))
{
Error.ThrowInternalError(errorcode);
}
return(value);
}
/// <summary>verify non-null and not completed</summary>
/// <param name="pereq">async result</param>
/// <param name="errorcode">error code if null or completed</param>
private static void CompleteCheck(QueryResult pereq, InternalError errorcode)
{
if ((null == pereq) || (pereq.IsCompletedInternally && !pereq.IsAborted))
{
// if aborting, let the request throw its abort code
Error.ThrowInternalError(errorcode);
}
}
/// <summary>verify non-null and not completed</summary>
/// <param name="pereq">async result</param>
/// <param name="errorcode">error code if null or completed</param>
protected override void CompleteCheck(PerRequest pereq, InternalError errorcode)
{
if ((null == pereq) || ((pereq.RequestCompleted || this.IsCompletedInternally) && !(this.IsAborted || pereq.RequestAborted)))
{
// if aborting, let the request throw its abort code
Error.ThrowInternalError(errorcode);
}
}
protected virtual void FinishCurrentChange(PerRequest pereq)
{
if (!pereq.RequestCompleted)
{
Error.ThrowInternalError(InternalError.SaveNextChangeIncomplete);
}
PerRequest perRequest = this.perRequest;
if (perRequest != null)
{
EqualRefCheck(perRequest, pereq, InternalError.InvalidSaveNextChange);
}
}
protected void AsyncEndGetRequestStream(IAsyncResult asyncResult)
{
AsyncStateBag asyncState = asyncResult.AsyncState as AsyncStateBag;
PerRequest request = (asyncState == null) ? null : asyncState.PerRequest;
DataServiceContext context = (asyncState == null) ? null : asyncState.Context;
try
{
this.CompleteCheck(request, InternalError.InvalidEndGetRequestCompleted);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
EqualRefCheck(this.perRequest, request, InternalError.InvalidEndGetRequestStream);
Stream stream = Util.NullCheck <Stream>(WebUtil.EndGetRequestStream(Util.NullCheck <ODataRequestMessageWrapper>(request.Request, InternalError.InvalidEndGetRequestStreamRequest), asyncResult, context), InternalError.InvalidEndGetRequestStreamStream);
request.RequestStream = stream;
ContentStream requestContentStream = request.RequestContentStream;
Util.NullCheck <ContentStream>(requestContentStream, InternalError.InvalidEndGetRequestStreamContent);
Util.NullCheck <Stream>(requestContentStream.Stream, InternalError.InvalidEndGetRequestStreamContent);
if (requestContentStream.IsKnownMemoryStream)
{
MemoryStream stream3 = requestContentStream.Stream as MemoryStream;
byte[] buffer = stream3.GetBuffer();
int position = (int)stream3.Position;
int num2 = ((int)stream3.Length) - position;
if ((buffer == null) || (num2 == 0))
{
Error.ThrowInternalError(InternalError.InvalidEndGetRequestStreamContentLength);
}
}
request.RequestContentBufferValidLength = -1;
Stream stream1 = requestContentStream.Stream;
asyncResult = InvokeAsync(new AsyncAction(stream1.BeginRead), request.RequestContentBuffer, 0, request.RequestContentBuffer.Length, new AsyncCallback(this.AsyncRequestContentEndRead), asyncState);
request.SetRequestCompletedSynchronously(asyncResult.CompletedSynchronously);
}
catch (Exception exception)
{
if (this.HandleFailure(request, exception))
{
throw;
}
}
finally
{
this.HandleCompleted(request);
}
}
private static void AsyncEndGetRequestStream(IAsyncResult asyncResult)
{
QueryAsyncResult state = asyncResult.AsyncState as QueryAsyncResult;
try
{
int step = CompleteCheck(state, InternalError.InvalidEndGetRequestCompleted);
state.CompletedSynchronously &= asyncResult.CompletedSynchronously; // BeginGetRequestStream
HttpWebRequest httpWebRequest = Util.NullCheck(state.Request, InternalError.InvalidEndGetRequestStreamRequest);
Stream stream = Util.NullCheck(httpWebRequest.EndGetRequestStream(asyncResult), InternalError.InvalidEndGetRequestStreamStream);
state.requestStream = stream;
MemoryStream memoryStream = Util.NullCheck(state.requestStreamContent, InternalError.InvalidEndGetRequestStreamContent);
byte[] buffer = memoryStream.GetBuffer();
int bufferOffset = checked ((int)memoryStream.Position);
int bufferLength = checked ((int)memoryStream.Length) - bufferOffset;
if ((null == buffer) || (0 == bufferLength))
{
Error.ThrowInternalError(InternalError.InvalidEndGetRequestStreamContentLength);
}
// the following is useful in the debugging Immediate Window
// string x = System.Text.Encoding.UTF8.GetString(buffer, bufferOffset, bufferLength);
asyncResult = stream.BeginWrite(buffer, bufferOffset, bufferLength, QueryAsyncResult.AsyncEndWrite, state);
bool reallyCompletedSynchronously = asyncResult.CompletedSynchronously && (step < state.asyncCompleteStep);
state.CompletedSynchronously &= reallyCompletedSynchronously; // BeginWrite
}
catch (Exception e)
{
if (state.HandleFailure(e))
{
throw;
}
}
finally
{
state.HandleCompleted();
}
}
protected override void HandleCompleted(BaseAsyncResult.PerRequest pereq)
{
Error.ThrowInternalError(InternalError.InvalidHandleCompleted);
}
/// <summary>Set the AsyncWait and invoke the user callback.</summary>
/// <param name="pereq">the request object</param>
/// <remarks>This method is not implemented for this class.</remarks>
protected override void HandleCompleted(BaseAsyncResult.PerRequest pereq)
{
Debug.Assert(false, "This method should never be called from GetReadStreamResult.");
Error.ThrowInternalError(InternalError.InvalidHandleCompleted);
}