internal IAsyncResult BeginSend(System.Uri requestUri, WebClientAsyncResult asyncResult, bool callWriteAsyncRequest)
{
if (readResponseAsyncCallback == null)
{
lock (InternalSyncObject)
{
if (readResponseAsyncCallback == null)
{
getRequestStreamAsyncCallback = new AsyncCallback(WebClientProtocol.GetRequestStreamAsyncCallback);
getResponseAsyncCallback = new AsyncCallback(WebClientProtocol.GetResponseAsyncCallback);
readResponseAsyncCallback = new AsyncCallback(WebClientProtocol.ReadResponseAsyncCallback);
}
}
}
WebRequest webRequest = this.GetWebRequest(requestUri);
asyncResult.Request = webRequest;
this.InitializeAsyncRequest(webRequest, asyncResult.InternalAsyncState);
if (callWriteAsyncRequest)
{
webRequest.BeginGetRequestStream(getRequestStreamAsyncCallback, asyncResult);
}
else
{
webRequest.BeginGetResponse(getResponseAsyncCallback, asyncResult);
}
if (!asyncResult.IsCompleted)
{
asyncResult.CombineCompletedSynchronously(false);
}
return asyncResult;
}
protected void CancelAsync(object userState)
{
WebClientAsyncResult result = (WebClientAsyncResult)mappings [userState];
if (result == null)
{
return;
}
mappings.Remove(userState);
result.Abort();
}
/// <include file='doc\ClientProtocol.uex' path='docs/doc[@for="ClientProtocol.CancelInvokeAsync"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected void CancelAsync(object userState)
{
if (userState == null)
{
userState = NullToken;
}
WebClientAsyncResult result = OperationCompleted(userState, new object[] { null }, null, true);
if (result != null)
{
result.Abort();
}
}
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol.InvokeAsync1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected void InvokeAsync(string methodName, string requestUrl, object[] parameters, SendOrPostCallback callback, object userState)
{
if (userState == null)
{
userState = NullToken;
}
AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(new UserToken(callback, userState));
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, null, null, new AsyncCallback(InvokeAsyncCallback), asyncOp);
try {
AsyncInvokes.Add(userState, asyncResult);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Error, this, "InvokeAsync", e);
}
Exception exception = new ArgumentException(Res.GetString(Res.AsyncDuplicateUserState), e);
InvokeCompletedEventArgs eventArgs = new InvokeCompletedEventArgs(new object[] { null }, exception, false, userState);
asyncOp.PostOperationCompleted(callback, eventArgs);
return;
}
try {
HttpClientMethod method = GetClientMethod(methodName);
MimeParameterWriter paramWriter = GetParameterWriter(method);
Uri requestUri = new Uri(requestUrl);
if (paramWriter != null)
{
paramWriter.RequestEncoding = RequestEncoding;
requestUrl = paramWriter.GetRequestUrl(requestUri.AbsoluteUri, parameters);
requestUri = new Uri(requestUrl, true);
}
asyncResult.InternalAsyncState = new InvokeAsyncState(method, paramWriter, parameters);
BeginSend(requestUri, asyncResult, paramWriter.UsesWriteRequest);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Error, this, "InvokeAsync", e);
}
OperationCompleted(userState, new object[] { null }, e, false);
}
}
protected void InvokeAsync(string methodName, object[] parameters, SendOrPostCallback callback, object userState)
{
if (userState == null)
{
userState = this.NullToken;
}
SoapHttpClientProtocol.InvokeAsyncState invokeAsyncState = new SoapHttpClientProtocol.InvokeAsyncState(methodName, parameters);
AsyncOperation operation = AsyncOperationManager.CreateOperation((object)new UserToken(callback, userState));
WebClientAsyncResult asyncResult = new WebClientAsyncResult((WebClientProtocol)this, (object)invokeAsyncState, (WebRequest)null, new AsyncCallback(this.InvokeAsyncCallback), (object)operation);
try
{
this.AsyncInvokes.Add(userState, (object)asyncResult);
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
else
{
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, (object)this, "InvokeAsync", ex);
}
InvokeCompletedEventArgs completedEventArgs = new InvokeCompletedEventArgs(new object[1], (Exception) new ArgumentException(System.Web.Services.Res.GetString("AsyncDuplicateUserState"), ex), false, userState);
operation.PostOperationCompleted(callback, (object)completedEventArgs);
return;
}
}
try
{
this.BeginSend(this.Uri, asyncResult, true);
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
else
{
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, (object)this, "InvokeAsync", ex);
}
this.OperationCompleted(userState, new object[1], ex, false);
}
}
}
internal WebClientAsyncResult OperationCompleted(object userState, object[] parameters, Exception e, bool canceled)
{
WebClientAsyncResult result = (WebClientAsyncResult)base.AsyncInvokes[userState];
if (result != null)
{
AsyncOperation asyncState = (AsyncOperation)result.AsyncState;
UserToken userSuppliedState = (UserToken)asyncState.UserSuppliedState;
InvokeCompletedEventArgs arg = new InvokeCompletedEventArgs(parameters, e, canceled, userState);
base.AsyncInvokes.Remove(userState);
asyncState.PostOperationCompleted(userSuppliedState.Callback, arg);
}
return(result);
}
protected void CancelAsync(object userState)
{
if (userState == null)
{
userState = base.NullToken;
}
object[] parameters = new object[1];
WebClientAsyncResult result = this.OperationCompleted(userState, parameters, null, true);
if (result != null)
{
result.Abort();
}
}
private void InvokeAsyncCallback(IAsyncResult result)
{
object[] parameters = null;
Exception e = null;
WebClientAsyncResult asyncResult = (WebClientAsyncResult)result;
if (asyncResult.Request != null)
{
object internalAsyncState = null;
Stream responseStream = null;
try
{
WebResponse response = base.EndSend(asyncResult, ref internalAsyncState, ref responseStream);
InvokeAsyncState state = (InvokeAsyncState)internalAsyncState;
parameters = this.ReadResponse(state.Message, response, responseStream, true);
}
catch (XmlException exception2)
{
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsyncCallback", exception2);
}
e = new InvalidOperationException(System.Web.Services.Res.GetString("WebResponseBadXml"), exception2);
}
catch (Exception exception3)
{
if (((exception3 is ThreadAbortException) || (exception3 is StackOverflowException)) || (exception3 is OutOfMemoryException))
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsyncCallback", exception3);
}
e = exception3;
}
finally
{
if (responseStream != null)
{
responseStream.Close();
}
}
}
AsyncOperation asyncState = (AsyncOperation)result.AsyncState;
UserToken userSuppliedState = (UserToken)asyncState.UserSuppliedState;
base.OperationCompleted(userSuppliedState.UserState, parameters, e, false);
}
static private void ReadAsyncResponse(WebClientAsyncResult client)
{
if (client.Response.ContentLength == 0)
{
client.Complete();
return;
}
try {
client.ResponseStream = client.Response.GetResponseStream();
ReadAsyncResponseStream(client);
}
catch (Exception e) {
ProcessAsyncException(client, e);
}
}
protected IAsyncResult BeginInvoke(string methodName, string requestUrl, object[] parameters, AsyncCallback callback, object asyncState)
{
HttpClientMethod clientMethod = this.GetClientMethod(methodName);
MimeParameterWriter parameterWriter = this.GetParameterWriter(clientMethod);
Uri requestUri = new Uri(requestUrl);
if (parameterWriter != null)
{
parameterWriter.RequestEncoding = base.RequestEncoding;
requestUrl = parameterWriter.GetRequestUrl(requestUri.AbsoluteUri, parameters);
requestUri = new Uri(requestUrl, true);
}
InvokeAsyncState internalAsyncState = new InvokeAsyncState(clientMethod, parameterWriter, parameters);
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, internalAsyncState, null, callback, asyncState);
return base.BeginSend(requestUri, asyncResult, parameterWriter.UsesWriteRequest);
}
internal WebClientAsyncResult OperationCompleted(object userState, object[] parameters, Exception e, bool canceled)
{
Debug.Assert(userState != null, "We should not call OperationCompleted with null user token.");
WebClientAsyncResult result = (WebClientAsyncResult)AsyncInvokes[userState];
if (result != null)
{
AsyncOperation asyncOp = (AsyncOperation)result.AsyncState;
UserToken token = (UserToken)asyncOp.UserSuppliedState;
InvokeCompletedEventArgs eventArgs = new InvokeCompletedEventArgs(parameters, e, canceled, userState);
AsyncInvokes.Remove(userState);
asyncOp.PostOperationCompleted(token.Callback, eventArgs);
}
return(result);
}
private void InvokeAsyncCallback(IAsyncResult result)
{
object[] parameters = (object[])null;
Exception e = (Exception)null;
WebClientAsyncResult clientAsyncResult = (WebClientAsyncResult)result;
if (clientAsyncResult.Request != null)
{
object internalAsyncState = (object)null;
Stream responseStream = (Stream)null;
try
{
WebResponse response = this.EndSend((IAsyncResult)clientAsyncResult, ref internalAsyncState, ref responseStream);
parameters = this.ReadResponse(((SoapHttpClientProtocol.InvokeAsyncState)internalAsyncState).Message, response, responseStream, true);
}
catch (XmlException ex)
{
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, (object)this, "InvokeAsyncCallback", (Exception)ex);
}
e = (Exception) new InvalidOperationException(System.Web.Services.Res.GetString("WebResponseBadXml"), (Exception)ex);
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
else
{
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, (object)this, "InvokeAsyncCallback", ex);
}
e = ex;
}
}
finally
{
if (responseStream != null)
{
responseStream.Close();
}
}
}
this.OperationCompleted(((UserToken)((AsyncOperation)result.AsyncState).UserSuppliedState).UserState, parameters, e, false);
}
protected void InvokeAsync(string methodName, object[] parameters, SendOrPostCallback callback, object userState)
{
if (userState == null)
{
userState = base.NullToken;
}
InvokeAsyncState internalAsyncState = new InvokeAsyncState(methodName, parameters);
AsyncOperation userAsyncState = AsyncOperationManager.CreateOperation(new UserToken(callback, userState));
WebClientAsyncResult result = new WebClientAsyncResult(this, internalAsyncState, null, new AsyncCallback(this.InvokeAsyncCallback), userAsyncState);
try
{
base.AsyncInvokes.Add(userState, result);
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", exception);
}
Exception exception2 = new ArgumentException(System.Web.Services.Res.GetString("AsyncDuplicateUserState"), exception);
object[] results = new object[1];
InvokeCompletedEventArgs arg = new InvokeCompletedEventArgs(results, exception2, false, userState);
userAsyncState.PostOperationCompleted(callback, arg);
return;
}
try
{
base.BeginSend(base.Uri, result, true);
}
catch (Exception exception3)
{
if (((exception3 is ThreadAbortException) || (exception3 is StackOverflowException)) || (exception3 is OutOfMemoryException))
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", exception3);
}
object[] objArray2 = new object[1];
base.OperationCompleted(userState, objArray2, exception3, false);
}
}
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol.BeginInvoke"]/*' />
/// <devdoc>
/// <para>
/// Starts an asynchronous invocation of a method of a HTTP web service.
/// </para>
/// </devdoc>
protected IAsyncResult BeginInvoke(string methodName, string requestUrl, object[] parameters, AsyncCallback callback, object asyncState)
{
HttpClientMethod method = GetClientMethod(methodName);
MimeParameterWriter paramWriter = GetParameterWriter(method);
Uri requestUri = new Uri(requestUrl);
if (paramWriter != null)
{
paramWriter.RequestEncoding = RequestEncoding;
requestUrl = paramWriter.GetRequestUrl(requestUri.AbsoluteUri, parameters);
requestUri = new Uri(requestUrl, true);
}
InvokeAsyncState invokeState = new InvokeAsyncState(method, paramWriter, parameters);
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, invokeState, null, callback, asyncState);
return(BeginSend(requestUri, asyncResult, paramWriter.UsesWriteRequest));
}
private void InvokeAsyncCallback(IAsyncResult result)
{
object[] parameters = null;
Exception exception = null;
WebClientAsyncResult asyncResult = (WebClientAsyncResult)result;
if (asyncResult.Request != null)
{
object o = null;
Stream responseStream = null;
try {
WebResponse response = EndSend(asyncResult, ref o, ref responseStream);
InvokeAsyncState invokeState = (InvokeAsyncState)o;
parameters = ReadResponse(invokeState.Message, response, responseStream, true);
}
catch (XmlException e) {
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsyncCallback", e);
}
exception = new InvalidOperationException(Res.GetString(Res.WebResponseBadXml), e);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsyncCallback", e);
}
exception = e;
}
finally {
if (responseStream != null)
{
responseStream.Close();
}
}
}
AsyncOperation asyncOp = (AsyncOperation)result.AsyncState;
UserToken token = (UserToken)asyncOp.UserSuppliedState;
OperationCompleted(token.UserState, parameters, exception, false);
}
static private void GetResponseAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult client = (WebClientAsyncResult)asyncResult.AsyncState;
client.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
try {
client.Response = client.ClientProtocol.GetWebResponse(client.Request, asyncResult);
}
catch (Exception e) {
ProcessAsyncException(client, e);
if (client.Response == null)
{
return;
}
}
ReadAsyncResponse(client);
}
internal WebResponse EndSend(IAsyncResult asyncResult, ref object internalAsyncState, ref Stream responseStream)
{
if (asyncResult == null)
{
throw new ArgumentNullException(Res.GetString("WebNullAsyncResultInEnd"));
}
WebClientAsyncResult result = (WebClientAsyncResult)asyncResult;
if (result.EndSendCalled)
{
throw new InvalidOperationException(Res.GetString("CanTCallTheEndMethodOfAnAsyncCallMoreThan"));
}
result.EndSendCalled = true;
WebResponse response = result.WaitForResponse();
internalAsyncState = result.InternalAsyncState;
responseStream = result.ResponseBufferedStream;
return(response);
}
static private void ReadAsyncResponse(WebClientAsyncResult client)
{
if (client.Response.ContentLength == 0)
{
client.Complete();
return;
}
try {
client.ResponseStream = client.Response.GetResponseStream();
ReadAsyncResponseStream(client);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
ProcessAsyncException(client, e, "ReadAsyncResponse");
}
}
static private void GetRequestStreamAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult client = (WebClientAsyncResult)asyncResult.AsyncState;
client.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
try {
Stream requestStream = client.Request.EndGetRequestStream(asyncResult);
try {
client.ClientProtocol.AsyncBufferedSerialize(client.Request, requestStream, client.InternalAsyncState);
}
finally {
requestStream.Close();
}
client.Request.BeginGetResponse(getResponseAsyncCallback, client);
}
catch (Exception e) {
ProcessAsyncException(client, e);
}
}
private static void ReadAsyncResponseStream(WebClientAsyncResult client)
{
IAsyncResult result;
do
{
byte[] buffer = client.Buffer;
long contentLength = client.Response.ContentLength;
if (buffer == null)
{
buffer = client.Buffer = new byte[(contentLength == -1L) ? ((int)0x400L) : ((int)contentLength)];
}
else if ((contentLength != -1L) && (contentLength > buffer.Length))
{
buffer = client.Buffer = new byte[contentLength];
}
result = client.ResponseStream.BeginRead(buffer, 0, buffer.Length, readResponseAsyncCallback, client);
}while (result.CompletedSynchronously && !ProcessAsyncResponseStreamResult(client, result));
}
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapClientProtocol.InvokeAsync1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected void InvokeAsync(string methodName, object[] parameters, SendOrPostCallback callback, object userState)
{
if (userState == null)
{
userState = NullToken;
}
InvokeAsyncState invokeState = new InvokeAsyncState(methodName, parameters);
AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(new UserToken(callback, userState));
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, invokeState, null, new AsyncCallback(InvokeAsyncCallback), asyncOp);
try {
AsyncInvokes.Add(userState, asyncResult);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", e);
}
Exception exception = new ArgumentException(Res.GetString(Res.AsyncDuplicateUserState), e);
InvokeCompletedEventArgs eventArgs = new InvokeCompletedEventArgs(new object[] { null }, exception, false, userState);
asyncOp.PostOperationCompleted(callback, eventArgs);
return;
}
try {
BeginSend(Uri, asyncResult, true);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", e);
}
OperationCompleted(userState, new object[] { null }, e, false);
}
}
static private void ReadResponseAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult client = (WebClientAsyncResult)asyncResult.AsyncState;
client.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
if (asyncResult.CompletedSynchronously)
{
return;
}
try {
bool complete = ProcessAsyncResponseStreamResult(client, asyncResult);
if (!complete)
{
ReadAsyncResponseStream(client);
}
}
catch (Exception e) {
ProcessAsyncException(client, e);
}
}
private static void ProcessAsyncException(WebClientAsyncResult client, Exception e, string method)
{
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Error, typeof(WebClientProtocol), method, e);
}
WebException exception = e as WebException;
if ((exception != null) && (exception.Response != null))
{
client.Response = exception.Response;
}
else
{
if (client.IsCompleted)
{
throw new InvalidOperationException(Res.GetString("ThereWasAnErrorDuringAsyncProcessing"), e);
}
client.Complete(e);
}
}
static private void GetResponseAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult client = (WebClientAsyncResult)asyncResult.AsyncState;
client.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
try {
client.Response = client.ClientProtocol.GetWebResponse(client.Request, asyncResult);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
ProcessAsyncException(client, e, "GetResponseAsyncCallback");
if (client.Response == null)
{
return;
}
}
ReadAsyncResponse(client);
}
static private void GetRequestStreamAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult client = (WebClientAsyncResult)asyncResult.AsyncState;
client.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
bool processingRequest = true;
try {
Stream requestStream = client.Request.EndGetRequestStream(asyncResult);
processingRequest = false;
try {
client.ClientProtocol.AsyncBufferedSerialize(client.Request, requestStream, client.InternalAsyncState);
}
finally {
requestStream.Close();
}
client.Request.BeginGetResponse(getResponseAsyncCallback, client);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
ProcessAsyncException(client, e, "GetRequestStreamAsyncCallback");
if (processingRequest)
{
WebException we = e as WebException;
if (we != null && we.Response != null)
{
// ProcessAsyncExcption doesn't call client.Complete() if there's a response,
// because it expects us to read the response. However, in certain cases
// (e.g. 502 errors), the exception thrown from Request can have a response.
// We don't process it, so call Complete() now.
client.Complete(e);
}
}
}
}
private static void GetRequestStreamAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult asyncState = (WebClientAsyncResult)asyncResult.AsyncState;
asyncState.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
bool flag = true;
try
{
Stream requestStream = asyncState.Request.EndGetRequestStream(asyncResult);
flag = false;
try
{
asyncState.ClientProtocol.AsyncBufferedSerialize(asyncState.Request, requestStream, asyncState.InternalAsyncState);
}
finally
{
requestStream.Close();
}
asyncState.Request.BeginGetResponse(getResponseAsyncCallback, asyncState);
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
ProcessAsyncException(asyncState, exception, "GetRequestStreamAsyncCallback");
if (flag)
{
WebException exception2 = exception as WebException;
if ((exception2 != null) && (exception2.Response != null))
{
asyncState.Complete(exception);
}
}
}
}
private static void GetResponseAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult asyncState = (WebClientAsyncResult)asyncResult.AsyncState;
asyncState.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
try
{
asyncState.Response = asyncState.ClientProtocol.GetWebResponse(asyncState.Request, asyncResult);
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
ProcessAsyncException(asyncState, exception, "GetResponseAsyncCallback");
if (asyncState.Response == null)
{
return;
}
}
ReadAsyncResponse(asyncState);
}
private static void ReadAsyncResponse(WebClientAsyncResult client)
{
if (client.Response.ContentLength == 0L)
{
client.Complete();
}
else
{
try
{
client.ResponseStream = client.Response.GetResponseStream();
ReadAsyncResponseStream(client);
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
ProcessAsyncException(client, exception, "ReadAsyncResponse");
}
}
}
static private void ProcessAsyncException(WebClientAsyncResult client, Exception e)
{
WebException webException = e as WebException;
if (webException != null && webException.Response != null)
{
client.Response = webException.Response;
}
else
{
// If we've already completed the call then the exception must have come
// out of the user callback in which case we need to rethrow it here
// so that it bubbles up to the AppDomain unhandled exception event.
if (client.IsCompleted)
{
throw new InvalidOperationException(Res.GetString(Res.ThereWasAnErrorDuringAsyncProcessing), e);
}
else
{
client.Complete(e);
}
}
}
static private void ReadAsyncResponseStream(WebClientAsyncResult client)
{
IAsyncResult asyncResult;
do
{
byte[] buffer = client.Buffer;
long contentLength = client.Response.ContentLength;
if (buffer == null)
{
buffer = client.Buffer = new byte[(contentLength == -1) ? 1024 : contentLength];
}
else if (contentLength != -1 && contentLength > buffer.Length)
{
buffer = client.Buffer = new byte[contentLength];
}
asyncResult = client.ResponseStream.BeginRead(buffer, 0, buffer.Length, readResponseAsyncCallback, client);
if (!asyncResult.CompletedSynchronously)
{
return;
}
}while (!ProcessAsyncResponseStreamResult(client, asyncResult));
}
static private void ReadResponseAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult client = (WebClientAsyncResult)asyncResult.AsyncState;
client.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
if (asyncResult.CompletedSynchronously)
{
return;
}
try {
bool complete = ProcessAsyncResponseStreamResult(client, asyncResult);
if (!complete)
{
ReadAsyncResponseStream(client);
}
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
ProcessAsyncException(client, e, "ReadResponseAsyncCallback");
}
}
private static void ReadResponseAsyncCallback(IAsyncResult asyncResult)
{
WebClientAsyncResult asyncState = (WebClientAsyncResult)asyncResult.AsyncState;
asyncState.CombineCompletedSynchronously(asyncResult.CompletedSynchronously);
if (!asyncResult.CompletedSynchronously)
{
try
{
if (!ProcessAsyncResponseStreamResult(asyncState, asyncResult))
{
ReadAsyncResponseStream(asyncState);
}
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
ProcessAsyncException(asyncState, exception, "ReadResponseAsyncCallback");
}
}
}
private void OK_Click(object sender, System.EventArgs e)
{
if (pendingAsyncResult != null)
{
connectionCancelled = true;
pendingAsyncResult.Abort();
pendingAsyncResult = null;
}
if (GameEngine.Current == null || dataGrid1.DataSource == null ||
this.BindingContext[dataGrid1.DataSource, "Table"] == null ||
this.BindingContext[dataGrid1.DataSource, "Table"].Count == 0)
{
this.Hide();
return;
}
DataRowView drv = (DataRowView)(this.BindingContext[dataGrid1.DataSource,"Table"].Current);
SpeciesService service = new SpeciesService();
service.Url = GameConfig.WebRoot + "/Species/AddSpecies.asmx";
service.Timeout = 60000;
byte [] speciesAssemblyBytes = null;
try
{
if (reintroduce)
{
speciesAssemblyBytes = service.ReintroduceSpecies((string)drv["Name"], Assembly.GetExecutingAssembly().GetName().Version.ToString(), GameEngine.Current.CurrentVector.State.StateGuid);
}
else
{
speciesAssemblyBytes = service.GetSpeciesAssembly((string)drv["Name"], Assembly.GetExecutingAssembly().GetName().Version.ToString());
}
}
catch(WebException)
{
MessageBox.Show(this, "The connection to the server timed out. Please try again later.");
}
if (speciesAssemblyBytes == null)
{
MessageBox.Show("Error retrieving species from server.");
}
else
{
dataSet.Tables["Table"].Rows.Remove(drv.Row);
// Save it to a temp file
string tempFile = PrivateAssemblyCache.GetSafeTempFileName();
using (Stream fileStream = File.OpenWrite(tempFile))
{
fileStream.Write(speciesAssemblyBytes, 0, (int) speciesAssemblyBytes.Length);
fileStream.Close();
}
try
{
GameEngine.Current.AddNewOrganism(tempFile, Point.Empty, reintroduce);
File.Delete(tempFile);
}
catch (TargetInvocationException exception)
{
Exception innerException = exception;
while (innerException.InnerException != null)
{
innerException = innerException.InnerException;
}
MessageBox.Show(innerException.Message, "Error Loading Assembly", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
catch (GameEngineException exception)
{
MessageBox.Show(exception.Message, "Error Loading Assembly", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
this.Hide();
}
}
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.BeginInvoke"]/*' />
/// <devdoc>
/// <para>
/// Starts an asynchronous invocation of a method of a SOAP web
/// service.
/// </para>
/// </devdoc>
protected IAsyncResult BeginInvoke(string methodName, object[] parameters, AsyncCallback callback, object asyncState) {
InvokeAsyncState invokeState = new InvokeAsyncState(methodName, parameters);
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, invokeState, null, callback, asyncState);
return BeginSend(Uri, asyncResult, true);
}
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapClientProtocol.InvokeAsync1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected void InvokeAsync(string methodName, object[] parameters, SendOrPostCallback callback, object userState) {
if (userState == null)
userState = NullToken;
InvokeAsyncState invokeState = new InvokeAsyncState(methodName, parameters);
AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(new UserToken(callback, userState));
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, invokeState, null, new AsyncCallback(InvokeAsyncCallback), asyncOp);
try {
AsyncInvokes.Add(userState, asyncResult);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
throw;
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", e);
Exception exception = new ArgumentException(Res.GetString(Res.AsyncDuplicateUserState), e);
InvokeCompletedEventArgs eventArgs = new InvokeCompletedEventArgs(new object[] { null }, exception, false, userState);
asyncOp.PostOperationCompleted(callback, eventArgs);
return;
}
try {
BeginSend(Uri, asyncResult, true);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
throw;
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", e);
OperationCompleted(userState, new object[] { null }, e, false);
}
}
internal void RegisterMapping (object userState, WebClientAsyncResult result)
{
}
private void ServerList_Click(object sender, EventArgs e)
{
this.retrievingData.Visible = true;
service = new SpeciesService();
service.Timeout = 10000;
service.Url = GameConfig.WebRoot + "/Species/AddSpecies.asmx";
try
{
if (reintroduce)
{
pendingAsyncResult = (WebClientAsyncResult) service.BeginGetExtinctSpecies(Assembly.GetExecutingAssembly().GetName().Version.ToString(), "", new AsyncCallback(ExtinctSpeciesCallback), null);
}
else
{
pendingAsyncResult = (WebClientAsyncResult) service.BeginGetAllSpecies(Assembly.GetExecutingAssembly().GetName().Version.ToString(), "", new AsyncCallback(AllSpeciesCallback), null);
}
}
catch(WebException)
{
MessageBox.Show(this, "The connection to the server timed out. Please try again later.");
}
}
void PasswordContinue_Clicked (object sender, EventArgs a)
{
notebook.Page = 5;
SettingsHandler.Settings.Key = entry_password.Text;
war = (WebClientAsyncResult) d.BeginGetSerial (entry_email.Text, entry_password.Text, new AsyncCallback (GetSerialDone), null);
}
void UploadDone (IAsyncResult iar)
{
try {
int result = d.EndSubmit (iar);
war = null;
if (result < 0)
state = State.SubmitError;
else {
state = State.Done;
serial = result;
}
} catch (Exception e) {
state = State.NetworkError;
Console.WriteLine ("Upload: " + e);
}
if (tn != null)
tn.WakeupMain ();
}
void VersionChecked (IAsyncResult iar)
{
try {
int ver = d.EndCheckVersion (iar);
war = null;
if (ver != 0)
state = State.VersionError;
else
state = State.GetSerial;
} catch (Exception e) {
Console.WriteLine ("Version: " + e);
state = State.NetworkError;
}
if (tn != null)
tn.WakeupMain ();
}
ConfigWizard (Browser browser)
{
tn = new ThreadNotify (new ReadyEvent (UpdateNotebookPage));
Glade.XML ui = new Glade.XML (null, "browser.glade", "window_config_wizard", null);
ui.Autoconnect (this);
//notebook.ShowTabs = false;
parent = browser;
window_config_wizard.TransientFor = browser.window1;
d = new Contributions ();
if (Environment.GetEnvironmentVariable ("MONODOCTESTING") == null)
d.Url = "http://www.go-mono.com/docs/server.asmx";
notebook.Page = 8;
war = (WebClientAsyncResult) d.BeginCheckVersion (1, new AsyncCallback (VersionChecked), null);
}
void ExtinctSpeciesCallback(IAsyncResult asyncResult)
{
try
{
pendingAsyncResult = null;
dataSet = service.EndGetExtinctSpecies(asyncResult);
cacheDate = DateTime.Now;
retrievingData.Visible = false;
}
catch
{
if (!connectionCancelled)
{
retrievingData.Text = "There was a problem getting species list from server.";
}
return;
}
this.Invalidate();
}
private void Cancel_Click(object sender, System.EventArgs e)
{
if (pendingAsyncResult != null)
{
connectionCancelled = true;
pendingAsyncResult.Abort();
pendingAsyncResult = null;
}
this.Hide();
}
internal void RegisterMapping (object userState, WebClientAsyncResult result)
{
if (userState == null)
userState = typeof (string);
mappings [userState] = result;
}
Upload (Browser browser)
{
tn = new ThreadNotify (new ReadyEvent (Update));
Glade.XML ui = new Glade.XML (null, "browser.glade", "upload_dialog", null);
ui.Autoconnect (this);
d = new Contributions ();
if (Environment.GetEnvironmentVariable ("MONODOCTESTING") == null)
d.Url = "http://www.go-mono.com/docs/server.asmx";
status.Text = "Checking Server version";
war = (WebClientAsyncResult) d.BeginCheckVersion (1, new AsyncCallback (VersionChecked), null);
}
void GetStatusDone (IAsyncResult iar)
{
try {
status = d.EndGetStatus (iar);
war = null;
if (status == null)
state = State.GetStatusError;
else
state = State.Done;
} catch (Exception e) {
state = State.NetworkError;
Console.WriteLine ("Error getting status: " + e);
}
if (tn != null)
tn.WakeupMain ();
}
void Update ()
{
Console.WriteLine ("In Update: " + state);
switch (state){
case State.NetworkError:
status.Text = "A network error ocurred";
cancel.Label = "Close";
return;
case State.VersionError:
status.Text = "Server has a different version, upgrade your MonoDoc";
cancel.Label = "Close";
return;
case State.GetSerial:
war = (WebClientAsyncResult) d.BeginGetSerial (
SettingsHandler.Settings.Email, SettingsHandler.Settings.Key,
new AsyncCallback (GetSerialDone), null);
return;
case State.SerialError:
status.Text = "Error obtaining serial number from server for this account";
cancel.Label = "Close";
return;
case State.SubmitError:
status.Text = "There was a problem with the documentation uploaded";
cancel.Label = "Close";
return;
case State.PrepareUpload:
GlobalChangeset cs = EditingUtils.GetChangesFrom (serial);
if (cs == null){
status.Text = "No new contributions";
cancel.Label = "Close";
return;
}
CopyXmlNodeWriter w = new CopyXmlNodeWriter ();
GlobalChangeset.serializer.Serialize (w, cs);
Console.WriteLine ("Uploading...");
status.Text = String.Format ("Uploading {0} contributions", cs.Count);
XmlDocument dd = (XmlDocument) w.Document;
war = (WebClientAsyncResult) d.BeginSubmit (
SettingsHandler.Settings.Email, SettingsHandler.Settings.Key,
((XmlDocument) w.Document).DocumentElement,
new AsyncCallback (UploadDone), null);
return;
case State.Done:
status.Text = "All contributions uploaded";
cancel.Label = "Close";
SettingsHandler.Settings.SerialNumber = serial;
SettingsHandler.Save ();
return;
}
}
protected void InvokeAsync(string methodName, string requestUrl, object[] parameters, SendOrPostCallback callback, object userState)
{
if (userState == null)
{
userState = base.NullToken;
}
AsyncOperation userAsyncState = AsyncOperationManager.CreateOperation(new UserToken(callback, userState));
WebClientAsyncResult result = new WebClientAsyncResult(this, null, null, new AsyncCallback(this.InvokeAsyncCallback), userAsyncState);
try
{
base.AsyncInvokes.Add(userState, result);
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Error, this, "InvokeAsync", exception);
}
Exception exception2 = new ArgumentException(Res.GetString("AsyncDuplicateUserState"), exception);
object[] results = new object[1];
InvokeCompletedEventArgs arg = new InvokeCompletedEventArgs(results, exception2, false, userState);
userAsyncState.PostOperationCompleted(callback, arg);
return;
}
try
{
HttpClientMethod clientMethod = this.GetClientMethod(methodName);
MimeParameterWriter parameterWriter = this.GetParameterWriter(clientMethod);
Uri requestUri = new Uri(requestUrl);
if (parameterWriter != null)
{
parameterWriter.RequestEncoding = base.RequestEncoding;
requestUrl = parameterWriter.GetRequestUrl(requestUri.AbsoluteUri, parameters);
requestUri = new Uri(requestUrl, true);
}
result.InternalAsyncState = new InvokeAsyncState(clientMethod, parameterWriter, parameters);
base.BeginSend(requestUri, result, parameterWriter.UsesWriteRequest);
}
catch (Exception exception3)
{
if (((exception3 is ThreadAbortException) || (exception3 is StackOverflowException)) || (exception3 is OutOfMemoryException))
{
throw;
}
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Error, this, "InvokeAsync", exception3);
}
object[] objArray2 = new object[1];
base.OperationCompleted(userState, objArray2, exception3, false);
}
}
void GetSerialDone (IAsyncResult iar)
{
try {
serial = d.EndGetSerial (iar);
war = null;
if (serial < 0)
state = State.SerialError;
else
state = State.PrepareUpload;
} catch (Exception e) {
Console.WriteLine ("Serial: " + e);
state = State.NetworkError;
}
if (tn != null)
tn.WakeupMain ();
}
/// <summary>
/// Callback method used by the reporting service methods to enable
/// Async reporting.
/// </summary>
/// <param name="asyncResult">The results of the method.</param>
private void ReportServiceCallback(IAsyncResult asyncResult)
{
try
{
var resultCode = _reportingService.EndReportPopulation(asyncResult);
switch (resultCode)
{
case ReturnCode.NodeTimedOut:
_timedOut = true;
break;
case ReturnCode.NodeCorrupted:
_nodeCorrupted = true;
break;
case ReturnCode.OrganismBlacklisted:
_organismBlacklisted = true;
break;
default:
if (resultCode != 0)
{
}
break;
}
if (_led != null)
{
_led.LedState = LedStates.Idle;
}
}
catch (SoapException e)
{
ErrorLog.LogHandledException(e);
if (_led != null)
{
_led.LedState = LedStates.Failed;
}
}
catch (Exception e)
{
ErrorLog.LogHandledException(e);
if (_led != null)
{
_led.LedState = LedStates.Failed;
}
}
finally
{
_pendingAsyncResult = null;
}
}
void Cancel_Clicked (object sender, EventArgs a)
{
if (war != null)
war.Abort ();
war = null;
state = State.Done;
upload_dialog.Destroy ();
upload_dialog = null;
tn = null;
}
/// <devdoc>
/// <para>
/// Starts async request processing including async retrieval of the request stream and response.
/// Derived classes can use BeginSend
/// to help implement their own higher level async methods like BeginInvoke. Derived
/// classes can add custom behavior by overriding GetWebRequest, GetWebResponse,
/// InitializeAsyncRequest and WriteAsyncRequest methods.
/// </para>
/// </devdoc>
internal IAsyncResult BeginSend(Uri requestUri, WebClientAsyncResult asyncResult, bool callWriteAsyncRequest) {
if (readResponseAsyncCallback == null) {
lock (InternalSyncObject) {
if (readResponseAsyncCallback == null) {
getRequestStreamAsyncCallback = new AsyncCallback(GetRequestStreamAsyncCallback);
getResponseAsyncCallback = new AsyncCallback(GetResponseAsyncCallback);
readResponseAsyncCallback = new AsyncCallback(ReadResponseAsyncCallback);
}
}
}
Debug.Assert(asyncResult.Request == null, "calling GetWebRequest twice for the same WebClientAsyncResult");
WebRequest request = GetWebRequest(requestUri);
asyncResult.Request = request;
InitializeAsyncRequest(request, asyncResult.InternalAsyncState);
if (callWriteAsyncRequest)
request.BeginGetRequestStream(getRequestStreamAsyncCallback, asyncResult);
else
request.BeginGetResponse(getResponseAsyncCallback, asyncResult);
if (!asyncResult.IsCompleted)
asyncResult.CombineCompletedSynchronously(false);
return asyncResult;
}
//
// Request the user registration.
//
void OnPage2_Clicked (object sender, EventArgs a)
{
notebook.Page = 2;
SettingsHandler.Settings.Email = entry_email.Text;
war = (WebClientAsyncResult) d.BeginRegister (entry_email.Text, new AsyncCallback (RegisterDone), null);
}
static private void ProcessAsyncException(WebClientAsyncResult client, Exception e, string method) {
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, typeof(WebClientProtocol), method, e);
WebException webException = e as WebException;
if (webException != null && webException.Response != null) {
client.Response = webException.Response;
}
else {
// If we've already completed the call then the exception must have come
// out of the user callback in which case we need to rethrow it here
// so that it bubbles up to the AppDomain unhandled exception event.
if (client.IsCompleted)
throw new InvalidOperationException(Res.GetString(Res.ThereWasAnErrorDuringAsyncProcessing), e);
else
client.Complete(e);
}
}
ContributionStatus (string email, string key)
{
tn = new ThreadNotify (new ReadyEvent (Update));
d = new Contributions ();
if (Environment.GetEnvironmentVariable ("MONODOCTESTING") == null)
d.Url = "http://www.go-mono.com/docs/server.asmx";
war = (WebClientAsyncResult) d.BeginGetStatus (email, key, new AsyncCallback (GetStatusDone), null);
contributoremail = email;
}
static private void ReadAsyncResponse(WebClientAsyncResult client) {
if (client.Response.ContentLength == 0) {
client.Complete();
return;
}
try {
client.ResponseStream = client.Response.GetResponseStream();
ReadAsyncResponseStream(client);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
ProcessAsyncException(client, e, "ReadAsyncResponse");
}
}
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol.InvokeAsync1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected void InvokeAsync(string methodName, string requestUrl, object[] parameters, SendOrPostCallback callback, object userState) {
if (userState == null)
userState = NullToken;
AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(new UserToken(callback, userState));
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, null, null, new AsyncCallback(InvokeAsyncCallback), asyncOp);
try {
AsyncInvokes.Add(userState, asyncResult);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
throw;
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, this, "InvokeAsync", e);
Exception exception = new ArgumentException(Res.GetString(Res.AsyncDuplicateUserState), e);
InvokeCompletedEventArgs eventArgs = new InvokeCompletedEventArgs(new object[] { null }, exception, false, userState);
asyncOp.PostOperationCompleted(callback, eventArgs);
return;
}
try {
HttpClientMethod method = GetClientMethod(methodName);
MimeParameterWriter paramWriter = GetParameterWriter(method);
Uri requestUri = new Uri(requestUrl);
if (paramWriter != null) {
paramWriter.RequestEncoding = RequestEncoding;
requestUrl = paramWriter.GetRequestUrl(requestUri.AbsoluteUri, parameters);
requestUri = new Uri(requestUrl, true);
}
asyncResult.InternalAsyncState = new InvokeAsyncState(method, paramWriter, parameters);
BeginSend(requestUri, asyncResult, paramWriter.UsesWriteRequest);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
throw;
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, this, "InvokeAsync", e);
OperationCompleted(userState, new object[] { null }, e, false);
}
}
static private void ReadAsyncResponseStream(WebClientAsyncResult client) {
IAsyncResult asyncResult;
do {
byte[] buffer = client.Buffer;
long contentLength = client.Response.ContentLength;
if (buffer == null)
buffer = client.Buffer = new byte[(contentLength == -1) ? 1024 : contentLength];
else if (contentLength != -1 && contentLength > buffer.Length)
buffer = client.Buffer = new byte[contentLength];
asyncResult = client.ResponseStream.BeginRead(buffer, 0, buffer.Length, readResponseAsyncCallback, client);
if (!asyncResult.CompletedSynchronously)
return;
}
while (!ProcessAsyncResponseStreamResult(client, asyncResult));
}
static private bool ProcessAsyncResponseStreamResult(WebClientAsyncResult client, IAsyncResult asyncResult) {
bool complete;
int bytesRead = client.ResponseStream.EndRead(asyncResult);
long contentLength = client.Response.ContentLength;
if (contentLength > 0 && bytesRead == contentLength) {
// the non-chunked response finished in a single read
client.ResponseBufferedStream = new MemoryStream(client.Buffer);
complete = true;
}
else if (bytesRead > 0) {
if (client.ResponseBufferedStream == null) {
int capacity = (int)((contentLength == -1) ? client.Buffer.Length : contentLength);
client.ResponseBufferedStream = new MemoryStream(capacity);
}
client.ResponseBufferedStream.Write(client.Buffer, 0, bytesRead);
complete = false;
}
else
complete = true;
if (complete)
client.Complete();
return complete;
}
protected void InvokeAsync(string methodName, object[] parameters, SendOrPostCallback callback, object userState)
{
if (userState == null)
userState = this.NullToken;
SoapHttpClientProtocol.InvokeAsyncState invokeAsyncState = new SoapHttpClientProtocol.InvokeAsyncState(methodName, parameters);
AsyncOperation operation = AsyncOperationManager.CreateOperation((object) new UserToken(callback, userState));
WebClientAsyncResult asyncResult = new WebClientAsyncResult((WebClientProtocol) this, (object) invokeAsyncState, (WebRequest) null, new AsyncCallback(this.InvokeAsyncCallback), (object) operation);
try
{
this.AsyncInvokes.Add(userState, (object) asyncResult);
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
else
{
if (Tracing.On)
Tracing.ExceptionCatch(TraceEventType.Warning, (object) this, "InvokeAsync", ex);
InvokeCompletedEventArgs completedEventArgs = new InvokeCompletedEventArgs(new object[1], (Exception) new ArgumentException(System.Web.Services.Res.GetString("AsyncDuplicateUserState"), ex), false, userState);
operation.PostOperationCompleted(callback, (object) completedEventArgs);
return;
}
}
try
{
this.BeginSend(this.Uri, asyncResult, true);
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
else
{
if (Tracing.On)
Tracing.ExceptionCatch(TraceEventType.Warning, (object) this, "InvokeAsync", ex);
this.OperationCompleted(userState, new object[1], ex, false);
}
}
}