protected IAsyncResult BeginInvoke(string methodName, string requestUrl, object[] parameters, AsyncCallback callback, object asyncState)
{
HttpSimpleMethodStubInfo method = (HttpSimpleMethodStubInfo)TypeStub.GetMethod(methodName);
SimpleWebClientAsyncResult ainfo = null;
try
{
MimeParameterWriter parameterWriter = (MimeParameterWriter)method.ParameterWriterType.Create();
string url = parameterWriter.GetRequestUrl(requestUrl, parameters);
WebRequest req = GetWebRequest(new Uri(url));
ainfo = new SimpleWebClientAsyncResult(req, callback, asyncState);
ainfo.Parameters = parameters;
ainfo.ParameterWriter = parameterWriter;
ainfo.Method = method;
ainfo.Request = req;
ainfo.Request.BeginGetRequestStream(new AsyncCallback(AsyncGetRequestStreamDone), ainfo);
RegisterMapping(asyncState, ainfo);
}
catch (Exception ex)
{
if (ainfo != null)
{
ainfo.SetCompleted(null, ex, false);
}
else
{
throw ex;
}
}
return(ainfo);
}
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);
}
}
/// <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);
}
}
/// <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);
return(BeginSend(requestUri, invokeState, callback, asyncState, paramWriter.UsesWriteRequest));
}
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));
}
protected object Invoke(string methodName, string requestUrl, object[] parameters)
{
HttpSimpleMethodStubInfo method = (HttpSimpleMethodStubInfo)TypeStub.GetMethod(methodName);
MimeParameterWriter parameterWriter = (MimeParameterWriter)method.ParameterWriterType.Create();
string url = parameterWriter.GetRequestUrl(requestUrl, parameters);
WebRequest request = GetWebRequest(new Uri(url, true));
parameterWriter.InitializeRequest(request, parameters);
if (parameterWriter.UsesWriteRequest)
{
Stream stream = request.GetRequestStream();
parameterWriter.WriteRequest(stream, parameters);
stream.Close();
}
WebResponse response = GetWebResponse(request);
MimeReturnReader returnReader = (MimeReturnReader)method.ReturnReaderType.Create();
return(returnReader.Read(response, response.GetResponseStream()));
}
internal InvokeAsyncState(HttpClientMethod method, MimeParameterWriter paramWriter, object[] parameters)
{
this.Method = method;
this.ParamWriter = paramWriter;
this.Parameters = parameters;
}
internal InvokeAsyncState(HttpClientMethod method, MimeParameterWriter paramWriter, object[] parameters)
{
this.Method = method;
this.ParamWriter = paramWriter;
this.Parameters = parameters;
}
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol.Invoke"]/*' />
/// <devdoc>
/// <para>
/// Invokes a method of a HTTP web service.
/// </para>
/// </devdoc>
protected object Invoke(string methodName, string requestUrl, object[] parameters)
{
WebResponse response = null;
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);
}
WebRequest request = null;
try {
request = GetWebRequest(requestUri);
PendingSyncRequest = request;
if (paramWriter != null)
{
paramWriter.InitializeRequest(request, parameters);
// CONSIDER,yannc: in future versions when we allow pluggable protocols
// we may want to let them write in the request stream even
// if there are no parameters.
if (paramWriter.UsesWriteRequest)
{
if (parameters.Length == 0)
{
request.ContentLength = 0;
}
else
{
Stream requestStream = null;
try {
requestStream = request.GetRequestStream();
paramWriter.WriteRequest(requestStream, parameters);
}
finally {
if (requestStream != null)
{
requestStream.Close();
}
}
}
}
}
response = GetWebResponse(request);
Stream responseStream = null;
if (response.ContentLength != 0)
{
responseStream = response.GetResponseStream();
}
return(ReadResponse(method, response, responseStream));
}
finally {
if (request == PendingSyncRequest)
{
PendingSyncRequest = null;
}
}
}
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol.Invoke"]/*' />
/// <devdoc>
/// <para>
/// Invokes a method of a HTTP web service.
/// </para>
/// </devdoc>
protected object Invoke(string methodName, string requestUrl, object[] parameters)
{
WebResponse response = null;
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);
}
WebRequest request = null;
try {
request = GetWebRequest(requestUri);
NotifyClientCallOut(request);
PendingSyncRequest = request;
if (paramWriter != null)
{
paramWriter.InitializeRequest(request, parameters);
//
if (paramWriter.UsesWriteRequest)
{
if (parameters.Length == 0)
{
request.ContentLength = 0;
}
else
{
Stream requestStream = null;
try {
requestStream = request.GetRequestStream();
paramWriter.WriteRequest(requestStream, parameters);
}
finally {
if (requestStream != null)
{
requestStream.Close();
}
}
}
}
}
response = GetWebResponse(request);
Stream responseStream = null;
if (response.ContentLength != 0)
{
responseStream = response.GetResponseStream();
}
return(ReadResponse(method, response, responseStream));
}
finally {
if (request == PendingSyncRequest)
{
PendingSyncRequest = null;
}
}
}
protected object Invoke(string methodName, string requestUrl, object[] parameters)
{
WebResponse webResponse = null;
object obj2;
HttpClientMethod clientMethod = this.GetClientMethod(methodName);
MimeParameterWriter parameterWriter = this.GetParameterWriter(clientMethod);
Uri uri = new Uri(requestUrl);
if (parameterWriter != null)
{
parameterWriter.RequestEncoding = base.RequestEncoding;
requestUrl = parameterWriter.GetRequestUrl(uri.AbsoluteUri, parameters);
uri = new Uri(requestUrl, true);
}
WebRequest webRequest = null;
try
{
webRequest = this.GetWebRequest(uri);
base.NotifyClientCallOut(webRequest);
base.PendingSyncRequest = webRequest;
if (parameterWriter != null)
{
parameterWriter.InitializeRequest(webRequest, parameters);
if (parameterWriter.UsesWriteRequest)
{
if (parameters.Length == 0)
{
webRequest.ContentLength = 0L;
}
else
{
Stream requestStream = null;
try
{
requestStream = webRequest.GetRequestStream();
parameterWriter.WriteRequest(requestStream, parameters);
}
finally
{
if (requestStream != null)
{
requestStream.Close();
}
}
}
}
}
webResponse = this.GetWebResponse(webRequest);
Stream responseStream = null;
if (webResponse.ContentLength != 0L)
{
responseStream = webResponse.GetResponseStream();
}
obj2 = this.ReadResponse(clientMethod, webResponse, responseStream);
}
finally
{
if (webRequest == base.PendingSyncRequest)
{
base.PendingSyncRequest = null;
}
}
return(obj2);
}
