mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
349 lines
16 KiB
C#
349 lines
16 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="HttpClientProtocol.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Services.Protocols {
|
|
using System;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Xml.Serialization;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.ComponentModel;
|
|
using System.Runtime.InteropServices;
|
|
using System.Diagnostics;
|
|
using System.Web.Services.Diagnostics;
|
|
|
|
internal class HttpClientMethod {
|
|
internal Type readerType;
|
|
internal object readerInitializer;
|
|
internal Type writerType;
|
|
internal object writerInitializer;
|
|
internal LogicalMethodInfo methodInfo;
|
|
}
|
|
|
|
internal class HttpClientType {
|
|
Hashtable methods = new Hashtable();
|
|
|
|
internal HttpClientType(Type type) {
|
|
LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(), LogicalMethodTypes.Sync);
|
|
|
|
Hashtable formatterTypes = new Hashtable();
|
|
for (int i = 0; i < methodInfos.Length; i++) {
|
|
LogicalMethodInfo methodInfo = methodInfos[i];
|
|
try {
|
|
object[] attributes = methodInfo.GetCustomAttributes(typeof(HttpMethodAttribute));
|
|
if (attributes.Length == 0) continue;
|
|
HttpMethodAttribute attribute = (HttpMethodAttribute)attributes[0];
|
|
HttpClientMethod method = new HttpClientMethod();
|
|
method.readerType = attribute.ReturnFormatter;
|
|
method.writerType = attribute.ParameterFormatter;
|
|
method.methodInfo = methodInfo;
|
|
AddFormatter(formatterTypes, method.readerType, method);
|
|
AddFormatter(formatterTypes, method.writerType, method);
|
|
methods.Add(methodInfo.Name, method);
|
|
}
|
|
catch (Exception e) {
|
|
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
|
|
throw;
|
|
}
|
|
throw new InvalidOperationException(Res.GetString(Res.WebReflectionError, methodInfo.DeclaringType.FullName, methodInfo.Name), e);
|
|
}
|
|
}
|
|
|
|
foreach (Type t in formatterTypes.Keys) {
|
|
ArrayList list = (ArrayList)formatterTypes[t];
|
|
LogicalMethodInfo[] m = new LogicalMethodInfo[list.Count];
|
|
for (int j = 0; j < list.Count; j++)
|
|
m[j] = ((HttpClientMethod)list[j]).methodInfo;
|
|
object[] initializers = MimeFormatter.GetInitializers(t, m);
|
|
bool isWriter = typeof(MimeParameterWriter).IsAssignableFrom(t);
|
|
for (int j = 0; j < list.Count; j++) {
|
|
if (isWriter) {
|
|
((HttpClientMethod)list[j]).writerInitializer = initializers[j];
|
|
}
|
|
else {
|
|
((HttpClientMethod)list[j]).readerInitializer = initializers[j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void AddFormatter(Hashtable formatterTypes, Type formatterType, HttpClientMethod method) {
|
|
if (formatterType == null) return;
|
|
ArrayList list = (ArrayList)formatterTypes[formatterType];
|
|
if (list == null) {
|
|
list = new ArrayList();
|
|
formatterTypes.Add(formatterType, list);
|
|
}
|
|
list.Add(method);
|
|
}
|
|
|
|
internal HttpClientMethod GetMethod(string name) {
|
|
return (HttpClientMethod)methods[name];
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Specifies
|
|
/// most of the implementation for communicating with an HTTP web service over HTTP.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[ComVisible(true)]
|
|
public abstract class HttpSimpleClientProtocol : HttpWebClientProtocol {
|
|
HttpClientType clientType;
|
|
|
|
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol.HttpSimpleClientProtocol"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Initializes a new instance of the <see cref='System.Web.Services.Protocols.HttpSimpleClientProtocol'/> class.
|
|
/// </para>
|
|
/// </devdoc>
|
|
protected HttpSimpleClientProtocol()
|
|
: base() {
|
|
Type type = this.GetType();
|
|
clientType = (HttpClientType)GetFromCache(type);
|
|
if (clientType == null) {
|
|
lock (InternalSyncObject) {
|
|
clientType = (HttpClientType)GetFromCache(type);
|
|
if (clientType == null) {
|
|
clientType = new HttpClientType(type);
|
|
AddToCache(type, clientType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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;
|
|
}
|
|
}
|
|
|
|
|
|
/// <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);
|
|
}
|
|
|
|
|
|
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol.InitializeAsyncRequest"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
internal override void InitializeAsyncRequest(WebRequest request, object internalAsyncState) {
|
|
InvokeAsyncState invokeState = (InvokeAsyncState)internalAsyncState;
|
|
if (invokeState.ParamWriter.UsesWriteRequest && invokeState.Parameters.Length == 0)
|
|
request.ContentLength = 0;
|
|
}
|
|
|
|
internal override void AsyncBufferedSerialize(WebRequest request, Stream requestStream, object internalAsyncState) {
|
|
InvokeAsyncState invokeState = (InvokeAsyncState)internalAsyncState;
|
|
if (invokeState.ParamWriter != null) {
|
|
invokeState.ParamWriter.InitializeRequest(request, invokeState.Parameters);
|
|
if (invokeState.ParamWriter.UsesWriteRequest && invokeState.Parameters.Length > 0)
|
|
invokeState.ParamWriter.WriteRequest(requestStream, invokeState.Parameters);
|
|
}
|
|
}
|
|
|
|
class InvokeAsyncState {
|
|
internal object[] Parameters;
|
|
internal MimeParameterWriter ParamWriter;
|
|
internal HttpClientMethod Method;
|
|
|
|
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.EndInvoke"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Ends an asynchronous invocation of a method of a HTTP web service.
|
|
/// </para>
|
|
/// </devdoc>
|
|
protected object EndInvoke(IAsyncResult asyncResult) {
|
|
object o = null;
|
|
Stream responseStream = null;
|
|
WebResponse response = EndSend(asyncResult, ref o, ref responseStream);
|
|
InvokeAsyncState invokeState = (InvokeAsyncState) o;
|
|
return ReadResponse(invokeState.Method, response, responseStream);
|
|
}
|
|
|
|
private void InvokeAsyncCallback(IAsyncResult result) {
|
|
object parameter = null;
|
|
Exception exception = null;
|
|
WebClientAsyncResult asyncResult = (WebClientAsyncResult)result;
|
|
if (asyncResult.Request != null) {
|
|
try {
|
|
object o = null;
|
|
Stream responseStream = null;
|
|
WebResponse response = EndSend(asyncResult, ref o, ref responseStream);
|
|
InvokeAsyncState invokeState = (InvokeAsyncState) o;
|
|
parameter = ReadResponse(invokeState.Method, response, responseStream);
|
|
}
|
|
catch (Exception e) {
|
|
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
|
|
throw;
|
|
exception = e;
|
|
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, this, "InvokeAsyncCallback", e);
|
|
}
|
|
}
|
|
AsyncOperation asyncOp = (AsyncOperation)result.AsyncState;
|
|
UserToken token = (UserToken)asyncOp.UserSuppliedState;
|
|
OperationCompleted(token.UserState, new object[] { parameter }, exception, false);
|
|
}
|
|
/// <include file='doc\HttpClientProtocol.uex' path='docs/doc[@for="HttpSimpleClientProtocol.InvokeAsync"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected void InvokeAsync(string methodName, string requestUrl, object[] parameters, SendOrPostCallback callback) {
|
|
InvokeAsync(methodName, requestUrl, parameters, callback, null);
|
|
}
|
|
|
|
/// <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);
|
|
}
|
|
}
|
|
|
|
MimeParameterWriter GetParameterWriter(HttpClientMethod method) {
|
|
if (method.writerType == null)
|
|
return null;
|
|
return (MimeParameterWriter)MimeFormatter.CreateInstance(method.writerType, method.writerInitializer);
|
|
}
|
|
|
|
HttpClientMethod GetClientMethod(string methodName) {
|
|
HttpClientMethod method = clientType.GetMethod(methodName);
|
|
if (method == null) throw new ArgumentException(Res.GetString(Res.WebInvalidMethodName, methodName), "methodName");
|
|
return method;
|
|
}
|
|
|
|
object ReadResponse(HttpClientMethod method, WebResponse response, Stream responseStream) {
|
|
HttpWebResponse httpResponse = response as HttpWebResponse;
|
|
if (httpResponse != null && (int)httpResponse.StatusCode >= 300)
|
|
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(httpResponse, responseStream), null,
|
|
WebExceptionStatus.ProtocolError, httpResponse);
|
|
|
|
if (method.readerType == null)
|
|
return null;
|
|
|
|
//
|
|
|
|
|
|
if (responseStream != null) {
|
|
MimeReturnReader reader = (MimeReturnReader)MimeFormatter.CreateInstance(method.readerType, method.readerInitializer);
|
|
return reader.Read(response, responseStream);
|
|
}
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
}
|