void Serialize(SoapClientMessage message)
{
Stream stream = message.Stream;
SoapClientMethod method = message.Method;
bool isEncoded = method.use == SoapBindingUse.Encoded;
// Serialize the message.
string envelopeNs = EnvelopeNs;
string encodingNs = EncodingNs;
XmlWriter writer = GetWriterForMessage(message, 1024);
if (writer == null)
{
throw new InvalidOperationException(Res.GetString(Res.WebNullWriterForMessage));
}
writer.WriteStartDocument();
writer.WriteStartElement(Soap.Prefix, Soap.Element.Envelope, envelopeNs);
writer.WriteAttributeString("xmlns", Soap.Prefix, null, envelopeNs);
if (isEncoded)
{
writer.WriteAttributeString("xmlns", "soapenc", null, encodingNs);
writer.WriteAttributeString("xmlns", "tns", null, clientType.serviceNamespace);
writer.WriteAttributeString("xmlns", "types", null, SoapReflector.GetEncodedNamespace(clientType.serviceNamespace, clientType.serviceDefaultIsEncoded));
}
writer.WriteAttributeString("xmlns", "xsi", null, XmlSchema.InstanceNamespace);
writer.WriteAttributeString("xmlns", "xsd", null, XmlSchema.Namespace);
SoapHeaderHandling.WriteHeaders(writer, method.inHeaderSerializer, message.Headers, method.inHeaderMappings, SoapHeaderDirection.In, isEncoded, clientType.serviceNamespace, clientType.serviceDefaultIsEncoded, envelopeNs);
writer.WriteStartElement(Soap.Element.Body, envelopeNs);
if (isEncoded && version != SoapProtocolVersion.Soap12) // don't write encodingStyle on soap:Body for soap 1.2
{
writer.WriteAttributeString("soap", Soap.Attribute.EncodingStyle, null, encodingNs);
}
object[] parameters = message.GetParameterValues();
TraceMethod caller = Tracing.On ? new TraceMethod(this, "Serialize") : null;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId(Res.TraceWriteRequest), caller, new TraceMethod(method.parameterSerializer, "Serialize", writer, parameters, null, isEncoded ? encodingNs : null));
}
method.parameterSerializer.Serialize(writer, parameters, null, isEncoded ? encodingNs : null);
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId(Res.TraceWriteRequest), caller);
}
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
// run the after serialize extension pass.
message.SetStage(SoapMessageStage.AfterSerialize);
message.RunExtensions(message.initializedExtensions, true);
}
private SoapClientMessage BeforeSerialize(WebRequest request, string methodName, object[] parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
SoapClientMethod method = this.clientType.GetMethod(methodName);
if (method == null)
{
throw new ArgumentException(System.Web.Services.Res.GetString("WebInvalidMethodName", new object[] { methodName }));
}
SoapReflectedExtension[] reflectedExtensions = (SoapReflectedExtension[])CombineExtensionsHelper(this.clientType.HighPriExtensions, method.extensions, this.clientType.LowPriExtensions, typeof(SoapReflectedExtension));
object[] extensionInitializers = (object[])CombineExtensionsHelper(this.clientType.HighPriExtensionInitializers, method.extensionInitializers, this.clientType.LowPriExtensionInitializers, typeof(object));
SoapExtension[] extensionArray2 = SoapMessage.InitializeExtensions(reflectedExtensions, extensionInitializers);
SoapClientMessage message = new SoapClientMessage(this, method, base.Url)
{
initializedExtensions = extensionArray2
};
if (extensionArray2 != null)
{
message.SetExtensionStream(new SoapExtensionStream());
}
message.InitExtensionStreamChain(message.initializedExtensions);
string action = UrlEncoder.EscapeString(method.action, Encoding.UTF8);
message.SetStage(SoapMessageStage.BeforeSerialize);
if (this.version == SoapProtocolVersion.Soap12)
{
message.ContentType = ContentType.Compose("application/soap+xml", (base.RequestEncoding != null) ? base.RequestEncoding : Encoding.UTF8, action);
}
else
{
message.ContentType = ContentType.Compose("text/xml", (base.RequestEncoding != null) ? base.RequestEncoding : Encoding.UTF8);
}
message.SetParameterValues(parameters);
SoapHeaderHandling.GetHeaderMembers(message.Headers, this, method.inHeaderMappings, SoapHeaderDirection.In, true);
message.RunExtensions(message.initializedExtensions, true);
request.ContentType = message.ContentType;
if ((message.ContentEncoding != null) && (message.ContentEncoding.Length > 0))
{
request.Headers["Content-Encoding"] = message.ContentEncoding;
}
request.Method = "POST";
if ((this.version != SoapProtocolVersion.Soap12) && (request.Headers["SOAPAction"] == null))
{
StringBuilder builder = new StringBuilder(action.Length + 2);
builder.Append('"');
builder.Append(action);
builder.Append('"');
request.Headers.Add("SOAPAction", builder.ToString());
}
return(message);
}
private SoapClientMessage BeforeSerialize(WebRequest request, string methodName, object[] parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
SoapClientMethod method = this.clientType.GetMethod(methodName);
if (method == null)
{
throw new ArgumentException(System.Web.Services.Res.GetString("WebInvalidMethodName", new object[1]
{
(object)methodName
}));
}
else
{
SoapExtension[] soapExtensionArray = SoapMessage.InitializeExtensions((SoapReflectedExtension[])SoapHttpClientProtocol.CombineExtensionsHelper((Array)this.clientType.HighPriExtensions, (Array)method.extensions, (Array)this.clientType.LowPriExtensions, typeof(SoapReflectedExtension)), (object[])SoapHttpClientProtocol.CombineExtensionsHelper((Array)this.clientType.HighPriExtensionInitializers, (Array)method.extensionInitializers, (Array)this.clientType.LowPriExtensionInitializers, typeof(object)));
SoapClientMessage soapClientMessage = new SoapClientMessage(this, method, this.Url);
soapClientMessage.initializedExtensions = soapExtensionArray;
if (soapExtensionArray != null)
{
soapClientMessage.SetExtensionStream(new SoapExtensionStream());
}
soapClientMessage.InitExtensionStreamChain(soapClientMessage.initializedExtensions);
string action = UrlEncoder.EscapeString(method.action, Encoding.UTF8);
soapClientMessage.SetStage(SoapMessageStage.BeforeSerialize);
if (this.version == SoapProtocolVersion.Soap12)
{
soapClientMessage.ContentType = ContentType.Compose("application/soap+xml", this.RequestEncoding != null ? this.RequestEncoding : Encoding.UTF8, action);
}
else
{
soapClientMessage.ContentType = ContentType.Compose("text/xml", this.RequestEncoding != null ? this.RequestEncoding : Encoding.UTF8);
}
soapClientMessage.SetParameterValues(parameters);
SoapHeaderHandling.GetHeaderMembers(soapClientMessage.Headers, (object)this, method.inHeaderMappings, SoapHeaderDirection.In, true);
soapClientMessage.RunExtensions(soapClientMessage.initializedExtensions, true);
request.ContentType = soapClientMessage.ContentType;
if (soapClientMessage.ContentEncoding != null && soapClientMessage.ContentEncoding.Length > 0)
{
((NameValueCollection)request.Headers)["Content-Encoding"] = soapClientMessage.ContentEncoding;
}
request.Method = "POST";
if (this.version != SoapProtocolVersion.Soap12 && ((NameValueCollection)request.Headers)["SOAPAction"] == null)
{
StringBuilder stringBuilder = new StringBuilder(action.Length + 2);
stringBuilder.Append('"');
stringBuilder.Append(action);
stringBuilder.Append('"');
((NameValueCollection)request.Headers).Add("SOAPAction", ((object)stringBuilder).ToString());
}
return(soapClientMessage);
}
}
private void Serialize(SoapClientMessage message)
{
Stream stream = message.Stream;
SoapClientMethod method = message.Method;
bool isEncoded = method.use == SoapBindingUse.Encoded;
string envelopeNs = this.EnvelopeNs;
string encodingNs = this.EncodingNs;
XmlWriter writerForMessage = this.GetWriterForMessage(message, 1024);
if (writerForMessage == null)
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebNullWriterForMessage"));
}
writerForMessage.WriteStartDocument();
writerForMessage.WriteStartElement("soap", "Envelope", envelopeNs);
writerForMessage.WriteAttributeString("xmlns", "soap", (string)null, envelopeNs);
if (isEncoded)
{
writerForMessage.WriteAttributeString("xmlns", "soapenc", (string)null, encodingNs);
writerForMessage.WriteAttributeString("xmlns", "tns", (string)null, this.clientType.serviceNamespace);
writerForMessage.WriteAttributeString("xmlns", "types", (string)null, SoapReflector.GetEncodedNamespace(this.clientType.serviceNamespace, this.clientType.serviceDefaultIsEncoded));
}
writerForMessage.WriteAttributeString("xmlns", "xsi", (string)null, "http://www.w3.org/2001/XMLSchema-instance");
writerForMessage.WriteAttributeString("xmlns", "xsd", (string)null, "http://www.w3.org/2001/XMLSchema");
SoapHeaderHandling.WriteHeaders(writerForMessage, method.inHeaderSerializer, message.Headers, method.inHeaderMappings, SoapHeaderDirection.In, isEncoded, this.clientType.serviceNamespace, this.clientType.serviceDefaultIsEncoded, envelopeNs);
writerForMessage.WriteStartElement("Body", envelopeNs);
if (isEncoded && this.version != SoapProtocolVersion.Soap12)
{
writerForMessage.WriteAttributeString("soap", "encodingStyle", (string)null, encodingNs);
}
object[] parameterValues = message.GetParameterValues();
TraceMethod caller = Tracing.On ? new TraceMethod((object)this, "Serialize", new object[0]) : (TraceMethod)null;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceWriteRequest"), caller, new TraceMethod((object)method.parameterSerializer, "Serialize", new object[4]
{
(object)writerForMessage,
(object)parameterValues,
null,
isEncoded ? (object)encodingNs : (object)(string)null
}));
}
method.parameterSerializer.Serialize(writerForMessage, (object)parameterValues, (XmlSerializerNamespaces)null, isEncoded ? encodingNs : (string)null);
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceWriteRequest"), caller);
}
writerForMessage.WriteEndElement();
writerForMessage.WriteEndElement();
writerForMessage.Flush();
message.SetStage(SoapMessageStage.AfterSerialize);
message.RunExtensions(message.initializedExtensions, true);
}
void Serialize(SoapClientMessage message)
{
Stream stream = message.Stream;
SoapClientMethod method = message.Method;
bool isEncoded = method.use == SoapBindingUse.Encoded;
// Serialize the message.
string envelopeNs = EnvelopeNs;
string encodingNs = EncodingNs;
StreamWriter sw = new StreamWriter(stream, RequestEncoding != null ? RequestEncoding : new UTF8Encoding(false), 128);
XmlTextWriter writer = isEncoded && message.Headers.Count > 0 ? new XmlSpecialTextWriter(sw, version) : new XmlTextWriter(sw);
writer.WriteStartDocument();
writer.WriteStartElement("soap", Soap.Envelope, envelopeNs);
writer.WriteAttributeString("xmlns", "soap", null, envelopeNs);
if (isEncoded)
{
writer.WriteAttributeString("xmlns", "soapenc", null, encodingNs);
writer.WriteAttributeString("xmlns", "tns", null, clientType.serviceNamespace);
writer.WriteAttributeString("xmlns", "types", null, SoapReflector.GetEncodedNamespace(clientType.serviceNamespace, clientType.serviceDefaultIsEncoded));
}
writer.WriteAttributeString("xmlns", "xsi", null, XmlSchema.InstanceNamespace);
writer.WriteAttributeString("xmlns", "xsd", null, XmlSchema.Namespace);
SoapHeaderHandling.WriteHeaders(writer, method.inHeaderSerializer, message.Headers, method.inHeaderMappings, SoapHeaderDirection.In, isEncoded, clientType.serviceNamespace, clientType.serviceDefaultIsEncoded, envelopeNs);
writer.WriteStartElement(Soap.Body, envelopeNs);
if (isEncoded)
{
writer.WriteAttributeString("soap", Soap.EncodingStyle, null, encodingNs);
}
// SOAP12: not using encodingStyle
//method.parameterSerializer.Serialize(writer, message.GetParameterValues(), null, isEncoded ? encodingNs : null);
method.parameterSerializer.Serialize(writer, message.GetParameterValues(), null);
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
// run the after serialize extension pass.
message.SetStage(SoapMessageStage.AfterSerialize);
message.RunExtensions(message.initializedExtensions);
}
object[] ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, bool asyncCall)
{
SoapClientMethod method = message.Method;
// CONSIDER,yannc: use the SoapExtensionStream here as well so we throw exceptions
// : if the extension touches stream properties/methods in before deserialize.
// note that if there is an error status code then the response might be content-type=text/plain.
HttpWebResponse httpResponse = response as HttpWebResponse;
int statusCode = httpResponse != null ? (int)httpResponse.StatusCode : -1;
if (statusCode >= 300 && statusCode != 500 && statusCode != 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(httpResponse, responseStream), null,
WebExceptionStatus.ProtocolError, httpResponse);
}
message.Headers.Clear();
message.SetStream(responseStream);
message.InitExtensionStreamChain(message.initializedExtensions);
message.SetStage(SoapMessageStage.BeforeDeserialize);
message.ContentType = response.ContentType;
message.ContentEncoding = response.Headers[ContentType.ContentEncoding];
message.RunExtensions(message.initializedExtensions);
if (method.oneWay && (httpResponse == null || (int)httpResponse.StatusCode != 500))
{
return(new object[0]);
}
// this statusCode check is just so we don't repeat the contentType check we did above
if (!ContentType.IsSoap(message.ContentType))
{
// special-case 400 since we exempted it above on the off-chance it might be a soap 1.2 sender fault.
// based on the content-type, it looks like it's probably just a regular old 400
if (statusCode == 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(httpResponse, responseStream), null,
WebExceptionStatus.ProtocolError, httpResponse);
}
else
{
throw new InvalidOperationException(Res.GetString(Res.WebResponseContent, message.ContentType, HttpContentType) +
"\r\n" +
RequestResponseUtils.CreateResponseExceptionString(response, responseStream));
}
}
Encoding enc = RequestResponseUtils.GetEncoding(message.ContentType);
// perf fix: changed buffer size passed to StreamReader
int bufferSize;
if (asyncCall || httpResponse == null)
{
bufferSize = 512;
}
else
{
int contentLength = (int)httpResponse.ContentLength;
if (contentLength == -1)
{
bufferSize = 8000;
}
else if (contentLength <= 16000)
{
bufferSize = contentLength;
}
else
{
bufferSize = 16000;
}
}
XmlTextReader reader;
if (enc != null)
{
reader = new XmlTextReader(new StreamReader(message.Stream, enc, true, bufferSize));
}
else
{
// CONSIDER: do i need to pass a buffer size somehow?
reader = new XmlTextReader(message.Stream);
}
reader.Normalization = true;
reader.XmlResolver = null;
reader.MoveToContent();
// should be able to handle no ns, soap 1.1 ns, or soap 1.2 ns
string encodingNs = EncodingNs;
string envelopeNs = reader.NamespaceURI;
if (envelopeNs == null || envelopeNs.Length == 0)
{
// ok to omit namespace -- assume correct version
reader.ReadStartElement(Soap.Envelope);
}
else if (reader.NamespaceURI == Soap.Namespace)
{
reader.ReadStartElement(Soap.Envelope, Soap.Namespace);
}
else if (reader.NamespaceURI == Soap12.Namespace)
{
reader.ReadStartElement(Soap.Envelope, Soap12.Namespace);
}
else
{
throw new SoapException(Res.GetString(Res.WebInvalidEnvelopeNamespace, envelopeNs, EnvelopeNs), SoapException.VersionMismatchFaultCode);
}
reader.MoveToContent();
SoapHeaderHandling headerHandler = new SoapHeaderHandling();
headerHandler.ReadHeaders(reader, method.outHeaderSerializer, message.Headers, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, envelopeNs, method.use == SoapBindingUse.Encoded ? encodingNs : null);
reader.MoveToContent();
reader.ReadStartElement(Soap.Body, envelopeNs);
reader.MoveToContent();
if (reader.IsStartElement(Soap.Fault, envelopeNs))
{
message.SetException(ReadSoapException(reader));
}
else
{
if (method.oneWay)
{
reader.Skip();
message.SetParameterValues(new object[0]);
}
else
{
// SOAP12: not using encodingStyle
//message.SetParameterValues((object[])method.returnSerializer.Deserialize(reader, method.use == SoapBindingUse.Encoded ? encodingNs : null));
message.SetParameterValues((object[])method.returnSerializer.Deserialize(reader));
}
}
while (reader.NodeType == XmlNodeType.Whitespace)
{
reader.Skip();
}
if (reader.NodeType == XmlNodeType.None)
{
reader.Skip();
}
else
{
reader.ReadEndElement();
}
while (reader.NodeType == XmlNodeType.Whitespace)
{
reader.Skip();
}
if (reader.NodeType == XmlNodeType.None)
{
reader.Skip();
}
else
{
reader.ReadEndElement();
}
message.SetStage(SoapMessageStage.AfterDeserialize);
message.RunExtensions(message.initializedExtensions);
SoapHeaderHandling.SetHeaderMembers(message.Headers, this, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, true);
if (message.Exception != null)
{
throw message.Exception;
}
return(message.GetParameterValues());
}
SoapClientMessage BeforeSerialize(WebRequest request, string methodName, object[] parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
SoapClientMethod method = clientType.GetMethod(methodName);
if (method == null)
{
throw new ArgumentException(Res.GetString(Res.WebInvalidMethodName, methodName));
}
// Run BeforeSerialize extension pass. Extensions are not allowed
// to write into the stream during this pass.
SoapReflectedExtension[] allExtensions = (SoapReflectedExtension[])CombineExtensionsHelper(clientType.HighPriExtensions, method.extensions, clientType.LowPriExtensions, typeof(SoapReflectedExtension));
object[] allExtensionInitializers = (object[])CombineExtensionsHelper(clientType.HighPriExtensionInitializers, method.extensionInitializers, clientType.LowPriExtensionInitializers, typeof(object));
SoapExtension[] initializedExtensions = SoapMessage.InitializeExtensions(allExtensions, allExtensionInitializers);
SoapClientMessage message = new SoapClientMessage(this, method, Url);
message.initializedExtensions = initializedExtensions;
if (initializedExtensions != null)
{
message.SetExtensionStream(new SoapExtensionStream());
}
message.InitExtensionStreamChain(message.initializedExtensions);
string soapAction = UrlEncoder.EscapeString(method.action, Encoding.UTF8);
message.SetStage(SoapMessageStage.BeforeSerialize);
if (this.version == SoapProtocolVersion.Soap12)
{
message.ContentType = ContentType.Compose(ContentType.ApplicationSoap, RequestEncoding != null ? RequestEncoding : Encoding.UTF8, soapAction);
}
else
{
message.ContentType = ContentType.Compose(ContentType.TextXml, RequestEncoding != null ? RequestEncoding : Encoding.UTF8);
}
message.SetParameterValues(parameters);
SoapHeaderHandling.GetHeaderMembers(message.Headers, this, method.inHeaderMappings, SoapHeaderDirection.In, true);
message.RunExtensions(message.initializedExtensions);
// Last chance to set request headers
request.ContentType = message.ContentType;
if (message.ContentEncoding != null && message.ContentEncoding.Length > 0)
{
request.Headers[ContentType.ContentEncoding] = message.ContentEncoding;
}
request.Method = "POST";
if (this.version != SoapProtocolVersion.Soap12 && request.Headers[Soap.Action] == null)
{
StringBuilder actionStringBuilder = new StringBuilder(soapAction.Length + 2);
actionStringBuilder.Append('"');
actionStringBuilder.Append(soapAction);
actionStringBuilder.Append('"');
request.Headers.Add(Soap.Action, actionStringBuilder.ToString());
}
return(message);
}
internal SoapClientType(Type type)
{
LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(BindingFlags.Public | BindingFlags.Instance), LogicalMethodTypes.Sync);
ArrayList mappings = new ArrayList();
ArrayList soapMethodList = new ArrayList();
this.binding = WebServiceBindingReflector.GetAttribute(type);
if (this.binding == null)
{
throw new InvalidOperationException(Res.GetString(Res.WebClientBindingAttributeRequired));
}
// Note: Service namespace is taken from WebserviceBindingAttribute and not WebserviceAttribute because
// the generated proxy does not have a WebServiceAttribute; however all have a WebServiceBindingAttribute.
serviceNamespace = binding.Namespace;
serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded);
XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded);
WebMethodReflector.IncludeTypes(methodInfos, xmlImporter);
SoapReflector.IncludeTypes(methodInfos, soapImporter);
SoapExtensionType[] extensionTypes = WebServicesConfiguration.Current.SoapExtensionTypes;
ArrayList highPri = new ArrayList();
ArrayList lowPri = new ArrayList();
for (int i = 0; i < extensionTypes.Length; i++)
{
SoapReflectedExtension extension = new SoapReflectedExtension(extensionTypes[i].Type, null, extensionTypes[i].Priority);
if (extensionTypes[i].Group == SoapExtensionType.PriorityGroup.High)
{
highPri.Add(extension);
}
else
{
lowPri.Add(extension);
}
}
HighPriExtensions = (SoapReflectedExtension[])highPri.ToArray(typeof(SoapReflectedExtension));
LowPriExtensions = (SoapReflectedExtension[])lowPri.ToArray(typeof(SoapReflectedExtension));
Array.Sort(HighPriExtensions);
Array.Sort(LowPriExtensions);
HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, HighPriExtensions);
LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, LowPriExtensions);
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, true, xmlImporter, soapImporter, serviceNamespace);
if (soapMethod == null)
{
continue;
}
soapMethodList.Add(soapMethod);
mappings.Add(soapMethod.requestMappings);
if (soapMethod.responseMappings != null)
{
mappings.Add(soapMethod.responseMappings);
}
mappings.Add(soapMethod.inHeaderMappings);
if (soapMethod.outHeaderMappings != null)
{
mappings.Add(soapMethod.outHeaderMappings);
}
}
XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping)));
int count = 0;
for (int i = 0; i < soapMethodList.Count; i++)
{
SoapReflectedMethod soapMethod = (SoapReflectedMethod)soapMethodList[i];
SoapClientMethod clientMethod = new SoapClientMethod();
clientMethod.parameterSerializer = serializers[count++];
if (soapMethod.responseMappings != null)
{
clientMethod.returnSerializer = serializers[count++];
}
clientMethod.inHeaderSerializer = serializers[count++];
if (soapMethod.outHeaderMappings != null)
{
clientMethod.outHeaderSerializer = serializers[count++];
}
clientMethod.action = soapMethod.action;
clientMethod.oneWay = soapMethod.oneWay;
clientMethod.rpc = soapMethod.rpc;
clientMethod.use = soapMethod.use;
clientMethod.paramStyle = soapMethod.paramStyle;
clientMethod.methodInfo = soapMethod.methodInfo;
clientMethod.extensions = soapMethod.extensions;
clientMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(clientMethod.methodInfo, soapMethod.extensions);
ArrayList inHeaders = new ArrayList();
ArrayList outHeaders = new ArrayList();
for (int j = 0; j < soapMethod.headers.Length; j++)
{
SoapHeaderMapping mapping = new SoapHeaderMapping();
SoapReflectedHeader soapHeader = soapMethod.headers[j];
mapping.memberInfo = soapHeader.memberInfo;
mapping.repeats = soapHeader.repeats;
mapping.custom = soapHeader.custom;
mapping.direction = soapHeader.direction;
mapping.headerType = soapHeader.headerType;
if ((mapping.direction & SoapHeaderDirection.In) != 0)
{
inHeaders.Add(mapping);
}
if ((mapping.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
{
outHeaders.Add(mapping);
}
}
clientMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping));
if (clientMethod.outHeaderSerializer != null)
{
clientMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping));
}
methods.Add(soapMethod.name, clientMethod);
}
}
internal SoapClientMessage(SoapHttpClientProtocol protocol, SoapClientMethod method, string url) {
this.method = method;
this.protocol = protocol;
this.url = url;
}
object[] ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, bool asyncCall)
{
SoapClientMethod method = message.Method;
//
HttpWebResponse httpResponse = response as HttpWebResponse;
int statusCode = httpResponse != null ? (int)httpResponse.StatusCode : -1;
if (statusCode >= 300 && statusCode != 500 && statusCode != 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(httpResponse, responseStream), null,
WebExceptionStatus.ProtocolError, httpResponse);
}
message.Headers.Clear();
message.SetStream(responseStream);
message.InitExtensionStreamChain(message.initializedExtensions);
message.SetStage(SoapMessageStage.BeforeDeserialize);
message.ContentType = response.ContentType;
message.ContentEncoding = response.Headers[ContentType.ContentEncoding];
message.RunExtensions(message.initializedExtensions, false);
if (method.oneWay && (httpResponse == null || (int)httpResponse.StatusCode != 500))
{
return(new object[0]);
}
// this statusCode check is just so we don't repeat the contentType check we did above
bool isSoap = ContentType.IsSoap(message.ContentType);
if (!isSoap || (isSoap && (httpResponse != null) && (httpResponse.ContentLength == 0)))
{
// special-case 400 since we exempted it above on the off-chance it might be a soap 1.2 sender fault.
// based on the content-type, it looks like it's probably just a regular old 400
if (statusCode == 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(httpResponse, responseStream), null,
WebExceptionStatus.ProtocolError, httpResponse);
}
else
{
throw new InvalidOperationException(Res.GetString(Res.WebResponseContent, message.ContentType, HttpContentType) +
Environment.NewLine +
RequestResponseUtils.CreateResponseExceptionString(response, responseStream));
}
}
if (message.Exception != null)
{
throw message.Exception;
}
// perf fix: changed buffer size passed to StreamReader
int bufferSize;
if (asyncCall || httpResponse == null)
{
bufferSize = 512;
}
else
{
bufferSize = RequestResponseUtils.GetBufferSize((int)httpResponse.ContentLength);
}
XmlReader reader = GetReaderForMessage(message, bufferSize);
if (reader == null)
{
throw new InvalidOperationException(Res.GetString(Res.WebNullReaderForMessage));
}
reader.MoveToContent();
int depth = reader.Depth;
// should be able to handle no ns, soap 1.1 ns, or soap 1.2 ns
string encodingNs = EncodingNs;
string envelopeNs = reader.NamespaceURI;
if (envelopeNs == null || envelopeNs.Length == 0)
{
// ok to omit namespace -- assume correct version
reader.ReadStartElement(Soap.Element.Envelope);
}
else if (reader.NamespaceURI == Soap.Namespace)
{
reader.ReadStartElement(Soap.Element.Envelope, Soap.Namespace);
}
else if (reader.NamespaceURI == Soap12.Namespace)
{
reader.ReadStartElement(Soap.Element.Envelope, Soap12.Namespace);
}
else
{
throw new SoapException(Res.GetString(Res.WebInvalidEnvelopeNamespace, envelopeNs, EnvelopeNs), SoapException.VersionMismatchFaultCode);
}
reader.MoveToContent();
SoapHeaderHandling headerHandler = new SoapHeaderHandling();
headerHandler.ReadHeaders(reader, method.outHeaderSerializer, message.Headers, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, envelopeNs, method.use == SoapBindingUse.Encoded ? encodingNs : null, false);
reader.MoveToContent();
reader.ReadStartElement(Soap.Element.Body, envelopeNs);
reader.MoveToContent();
if (reader.IsStartElement(Soap.Element.Fault, envelopeNs))
{
message.Exception = ReadSoapException(reader);
}
else
{
if (method.oneWay)
{
reader.Skip();
message.SetParameterValues(new object[0]);
}
else
{
TraceMethod caller = Tracing.On ? new TraceMethod(this, "ReadResponse") : null;
bool isEncodedSoap = method.use == SoapBindingUse.Encoded;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId(Res.TraceReadResponse), caller, new TraceMethod(method.returnSerializer, "Deserialize", reader, isEncodedSoap ? encodingNs : null));
}
bool useDeserializationEvents = !isEncodedSoap && (WebServicesSection.Current.SoapEnvelopeProcessing.IsStrict || Tracing.On);
if (useDeserializationEvents)
{
XmlDeserializationEvents events = Tracing.On ? Tracing.GetDeserializationEvents() : RuntimeUtils.GetDeserializationEvents();
message.SetParameterValues((object[])method.returnSerializer.Deserialize(reader, null, events));
}
else
{
message.SetParameterValues((object[])method.returnSerializer.Deserialize(reader, isEncodedSoap ? encodingNs : null));
}
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId(Res.TraceReadResponse), caller);
}
}
}
// Consume soap:Body and soap:Envelope closing tags
while (depth < reader.Depth && reader.Read())
{
// Nothing, just read on
}
// consume end tag
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.Read();
}
message.SetStage(SoapMessageStage.AfterDeserialize);
message.RunExtensions(message.initializedExtensions, false);
SoapHeaderHandling.SetHeaderMembers(message.Headers, this, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, true);
if (message.Exception != null)
{
throw message.Exception;
}
return(message.GetParameterValues());
}
internal SoapClientType(Type type)
{
this.binding = WebServiceBindingReflector.GetAttribute(type);
if (this.binding == null)
{
throw new InvalidOperationException(Res.GetString(Res.WebClientBindingAttributeRequired));
}
// Note: Service namespace is taken from WebserviceBindingAttribute and not WebserviceAttribute because
// the generated proxy does not have a WebServiceAttribute; however all have a WebServiceBindingAttribute.
serviceNamespace = binding.Namespace;
serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
ArrayList soapMethodList = new ArrayList();
ArrayList mappings = new ArrayList();
GenerateXmlMappings(type, soapMethodList, serviceNamespace, serviceDefaultIsEncoded, mappings);
XmlMapping[] xmlMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));
TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", type) : null;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId(Res.TraceCreateSerializer), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", xmlMappings, type));
}
XmlSerializer[] serializers = XmlSerializer.FromMappings(xmlMappings, type);
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId(Res.TraceCreateSerializer), caller);
}
SoapExtensionTypeElementCollection extensionTypes = WebServicesSection.Current.SoapExtensionTypes;
ArrayList highPri = new ArrayList();
ArrayList lowPri = new ArrayList();
for (int i = 0; i < extensionTypes.Count; i++)
{
SoapExtensionTypeElement element = extensionTypes[i];
SoapReflectedExtension extension = new SoapReflectedExtension(extensionTypes[i].Type, null, extensionTypes[i].Priority);
if (extensionTypes[i].Group == PriorityGroup.High)
{
highPri.Add(extension);
}
else
{
lowPri.Add(extension);
}
}
HighPriExtensions = (SoapReflectedExtension[])highPri.ToArray(typeof(SoapReflectedExtension));
LowPriExtensions = (SoapReflectedExtension[])lowPri.ToArray(typeof(SoapReflectedExtension));
Array.Sort(HighPriExtensions);
Array.Sort(LowPriExtensions);
HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, HighPriExtensions);
LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, LowPriExtensions);
int count = 0;
for (int i = 0; i < soapMethodList.Count; i++)
{
SoapReflectedMethod soapMethod = (SoapReflectedMethod)soapMethodList[i];
SoapClientMethod clientMethod = new SoapClientMethod();
clientMethod.parameterSerializer = serializers[count++];
if (soapMethod.responseMappings != null)
{
clientMethod.returnSerializer = serializers[count++];
}
clientMethod.inHeaderSerializer = serializers[count++];
if (soapMethod.outHeaderMappings != null)
{
clientMethod.outHeaderSerializer = serializers[count++];
}
clientMethod.action = soapMethod.action;
clientMethod.oneWay = soapMethod.oneWay;
clientMethod.rpc = soapMethod.rpc;
clientMethod.use = soapMethod.use;
clientMethod.paramStyle = soapMethod.paramStyle;
clientMethod.methodInfo = soapMethod.methodInfo;
clientMethod.extensions = soapMethod.extensions;
clientMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(clientMethod.methodInfo, soapMethod.extensions);
ArrayList inHeaders = new ArrayList();
ArrayList outHeaders = new ArrayList();
for (int j = 0; j < soapMethod.headers.Length; j++)
{
SoapHeaderMapping mapping = new SoapHeaderMapping();
SoapReflectedHeader soapHeader = soapMethod.headers[j];
mapping.memberInfo = soapHeader.memberInfo;
mapping.repeats = soapHeader.repeats;
mapping.custom = soapHeader.custom;
mapping.direction = soapHeader.direction;
mapping.headerType = soapHeader.headerType;
if ((mapping.direction & SoapHeaderDirection.In) != 0)
{
inHeaders.Add(mapping);
}
if ((mapping.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
{
outHeaders.Add(mapping);
}
}
clientMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping));
if (clientMethod.outHeaderSerializer != null)
{
clientMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping));
}
methods.Add(soapMethod.name, clientMethod);
}
}
internal SoapClientMessage(SoapHttpClientProtocol protocol, SoapClientMethod method, string url)
{
this.method = method;
this.protocol = protocol;
this.url = url;
}
internal SoapClientType(Type type)
{
this.binding = WebServiceBindingReflector.GetAttribute(type);
if (this.binding == null)
{
throw new InvalidOperationException(Res.GetString("WebClientBindingAttributeRequired"));
}
this.serviceNamespace = this.binding.Namespace;
this.serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
ArrayList soapMethodList = new ArrayList();
ArrayList mappings = new ArrayList();
GenerateXmlMappings(type, soapMethodList, this.serviceNamespace, this.serviceDefaultIsEncoded, mappings);
XmlMapping[] mappingArray = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));
TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", new object[] { type }) : null;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappingArray, type }));
}
XmlSerializer[] serializerArray = XmlSerializer.FromMappings(mappingArray, type);
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller);
}
SoapExtensionTypeElementCollection soapExtensionTypes = WebServicesSection.Current.SoapExtensionTypes;
ArrayList list3 = new ArrayList();
ArrayList list4 = new ArrayList();
for (int i = 0; i < soapExtensionTypes.Count; i++)
{
SoapExtensionTypeElement element1 = soapExtensionTypes[i];
SoapReflectedExtension extension = new SoapReflectedExtension(soapExtensionTypes[i].Type, null, soapExtensionTypes[i].Priority);
if (soapExtensionTypes[i].Group == PriorityGroup.High)
{
list3.Add(extension);
}
else
{
list4.Add(extension);
}
}
this.HighPriExtensions = (SoapReflectedExtension[])list3.ToArray(typeof(SoapReflectedExtension));
this.LowPriExtensions = (SoapReflectedExtension[])list4.ToArray(typeof(SoapReflectedExtension));
Array.Sort <SoapReflectedExtension>(this.HighPriExtensions);
Array.Sort <SoapReflectedExtension>(this.LowPriExtensions);
this.HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.HighPriExtensions);
this.LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.LowPriExtensions);
int num2 = 0;
for (int j = 0; j < soapMethodList.Count; j++)
{
SoapReflectedMethod method2 = (SoapReflectedMethod)soapMethodList[j];
SoapClientMethod method3 = new SoapClientMethod {
parameterSerializer = serializerArray[num2++]
};
if (method2.responseMappings != null)
{
method3.returnSerializer = serializerArray[num2++];
}
method3.inHeaderSerializer = serializerArray[num2++];
if (method2.outHeaderMappings != null)
{
method3.outHeaderSerializer = serializerArray[num2++];
}
method3.action = method2.action;
method3.oneWay = method2.oneWay;
method3.rpc = method2.rpc;
method3.use = method2.use;
method3.paramStyle = method2.paramStyle;
method3.methodInfo = method2.methodInfo;
method3.extensions = method2.extensions;
method3.extensionInitializers = SoapReflectedExtension.GetInitializers(method3.methodInfo, method2.extensions);
ArrayList list5 = new ArrayList();
ArrayList list6 = new ArrayList();
for (int k = 0; k < method2.headers.Length; k++)
{
SoapHeaderMapping mapping = new SoapHeaderMapping();
SoapReflectedHeader header = method2.headers[k];
mapping.memberInfo = header.memberInfo;
mapping.repeats = header.repeats;
mapping.custom = header.custom;
mapping.direction = header.direction;
mapping.headerType = header.headerType;
if ((mapping.direction & SoapHeaderDirection.In) != 0)
{
list5.Add(mapping);
}
if ((mapping.direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0)
{
list6.Add(mapping);
}
}
method3.inHeaderMappings = (SoapHeaderMapping[])list5.ToArray(typeof(SoapHeaderMapping));
if (method3.outHeaderSerializer != null)
{
method3.outHeaderMappings = (SoapHeaderMapping[])list6.ToArray(typeof(SoapHeaderMapping));
}
this.methods.Add(method2.name, method3);
}
}
private object[] ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, bool asyncCall)
{
SoapClientMethod method = message.Method;
HttpWebResponse httpWebResponse = response as HttpWebResponse;
int num1 = httpWebResponse != null ? (int)httpWebResponse.StatusCode : -1;
if (num1 >= 300 && num1 != 500 && num1 != 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString((WebResponse)httpWebResponse, responseStream), (Exception)null, WebExceptionStatus.ProtocolError, (WebResponse)httpWebResponse);
}
message.Headers.Clear();
message.SetStream(responseStream);
message.InitExtensionStreamChain(message.initializedExtensions);
message.SetStage(SoapMessageStage.BeforeDeserialize);
message.ContentType = response.ContentType;
message.ContentEncoding = ((NameValueCollection)response.Headers)["Content-Encoding"];
message.RunExtensions(message.initializedExtensions, false);
if (method.oneWay && (httpWebResponse == null || httpWebResponse.StatusCode != HttpStatusCode.InternalServerError))
{
return(new object[0]);
}
bool flag1 = ContentType.IsSoap(message.ContentType);
if (!flag1 || flag1 && httpWebResponse != null && httpWebResponse.ContentLength == 0L)
{
if (num1 == 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString((WebResponse)httpWebResponse, responseStream), (Exception)null, WebExceptionStatus.ProtocolError, (WebResponse)httpWebResponse);
}
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebResponseContent", (object)message.ContentType, (object)this.HttpContentType) + Environment.NewLine + RequestResponseUtils.CreateResponseExceptionString(response, responseStream));
}
else
{
if (message.Exception != null)
{
throw message.Exception;
}
int bufferSize = asyncCall || httpWebResponse == null ? 512 : RequestResponseUtils.GetBufferSize((int)httpWebResponse.ContentLength);
XmlReader readerForMessage = this.GetReaderForMessage(message, bufferSize);
if (readerForMessage == null)
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebNullReaderForMessage"));
}
int num2 = (int)readerForMessage.MoveToContent();
int depth = readerForMessage.Depth;
string encodingNs = this.EncodingNs;
string namespaceUri = readerForMessage.NamespaceURI;
if (namespaceUri == null || namespaceUri.Length == 0)
{
readerForMessage.ReadStartElement("Envelope");
}
else if (readerForMessage.NamespaceURI == "http://schemas.xmlsoap.org/soap/envelope/")
{
readerForMessage.ReadStartElement("Envelope", "http://schemas.xmlsoap.org/soap/envelope/");
}
else if (readerForMessage.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope")
{
readerForMessage.ReadStartElement("Envelope", "http://www.w3.org/2003/05/soap-envelope");
}
else
{
throw new SoapException(System.Web.Services.Res.GetString("WebInvalidEnvelopeNamespace", (object)namespaceUri, (object)this.EnvelopeNs), SoapException.VersionMismatchFaultCode);
}
int num3 = (int)readerForMessage.MoveToContent();
new SoapHeaderHandling().ReadHeaders(readerForMessage, method.outHeaderSerializer, message.Headers, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, namespaceUri, method.use == SoapBindingUse.Encoded ? encodingNs : (string)null, false);
int num4 = (int)readerForMessage.MoveToContent();
readerForMessage.ReadStartElement("Body", namespaceUri);
int num5 = (int)readerForMessage.MoveToContent();
if (readerForMessage.IsStartElement("Fault", namespaceUri))
{
message.Exception = this.ReadSoapException(readerForMessage);
}
else if (method.oneWay)
{
readerForMessage.Skip();
message.SetParameterValues(new object[0]);
}
else
{
TraceMethod caller = Tracing.On ? new TraceMethod((object)this, "ReadResponse", new object[0]) : (TraceMethod)null;
bool flag2 = method.use == SoapBindingUse.Encoded;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceReadResponse"), caller, new TraceMethod((object)method.returnSerializer, "Deserialize", new object[2]
{
(object)readerForMessage,
flag2 ? (object)encodingNs : (object)(string)null
}));
}
if (!flag2 && (WebServicesSection.Current.SoapEnvelopeProcessing.IsStrict || Tracing.On))
{
XmlDeserializationEvents events = Tracing.On ? Tracing.GetDeserializationEvents() : RuntimeUtils.GetDeserializationEvents();
message.SetParameterValues((object[])method.returnSerializer.Deserialize(readerForMessage, (string)null, events));
}
else
{
message.SetParameterValues((object[])method.returnSerializer.Deserialize(readerForMessage, flag2 ? encodingNs : (string)null));
}
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceReadResponse"), caller);
}
}
do
{
;
}while (depth < readerForMessage.Depth && readerForMessage.Read());
if (readerForMessage.NodeType == XmlNodeType.EndElement)
{
readerForMessage.Read();
}
message.SetStage(SoapMessageStage.AfterDeserialize);
message.RunExtensions(message.initializedExtensions, false);
SoapHeaderHandling.SetHeaderMembers(message.Headers, (object)this, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, true);
if (message.Exception != null)
{
throw message.Exception;
}
else
{
return(message.GetParameterValues());
}
}
}
internal SoapClientType(Type type)
{
this.binding = WebServiceBindingReflector.GetAttribute(type);
if (this.binding == null)
{
throw new InvalidOperationException(Res.GetString("WebClientBindingAttributeRequired"));
}
this.serviceNamespace = this.binding.Namespace;
this.serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
ArrayList soapMethodList = new ArrayList();
ArrayList mappings = new ArrayList();
GenerateXmlMappings(type, soapMethodList, this.serviceNamespace, this.serviceDefaultIsEncoded, mappings);
XmlMapping[] mappingArray = (XmlMapping[]) mappings.ToArray(typeof(XmlMapping));
TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", new object[] { type }) : null;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappingArray, type }));
}
XmlSerializer[] serializerArray = XmlSerializer.FromMappings(mappingArray, type);
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller);
}
SoapExtensionTypeElementCollection soapExtensionTypes = WebServicesSection.Current.SoapExtensionTypes;
ArrayList list3 = new ArrayList();
ArrayList list4 = new ArrayList();
for (int i = 0; i < soapExtensionTypes.Count; i++)
{
SoapExtensionTypeElement element1 = soapExtensionTypes[i];
SoapReflectedExtension extension = new SoapReflectedExtension(soapExtensionTypes[i].Type, null, soapExtensionTypes[i].Priority);
if (soapExtensionTypes[i].Group == PriorityGroup.High)
{
list3.Add(extension);
}
else
{
list4.Add(extension);
}
}
this.HighPriExtensions = (SoapReflectedExtension[]) list3.ToArray(typeof(SoapReflectedExtension));
this.LowPriExtensions = (SoapReflectedExtension[]) list4.ToArray(typeof(SoapReflectedExtension));
Array.Sort<SoapReflectedExtension>(this.HighPriExtensions);
Array.Sort<SoapReflectedExtension>(this.LowPriExtensions);
this.HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.HighPriExtensions);
this.LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.LowPriExtensions);
int num2 = 0;
for (int j = 0; j < soapMethodList.Count; j++)
{
SoapReflectedMethod method2 = (SoapReflectedMethod) soapMethodList[j];
SoapClientMethod method3 = new SoapClientMethod {
parameterSerializer = serializerArray[num2++]
};
if (method2.responseMappings != null)
{
method3.returnSerializer = serializerArray[num2++];
}
method3.inHeaderSerializer = serializerArray[num2++];
if (method2.outHeaderMappings != null)
{
method3.outHeaderSerializer = serializerArray[num2++];
}
method3.action = method2.action;
method3.oneWay = method2.oneWay;
method3.rpc = method2.rpc;
method3.use = method2.use;
method3.paramStyle = method2.paramStyle;
method3.methodInfo = method2.methodInfo;
method3.extensions = method2.extensions;
method3.extensionInitializers = SoapReflectedExtension.GetInitializers(method3.methodInfo, method2.extensions);
ArrayList list5 = new ArrayList();
ArrayList list6 = new ArrayList();
for (int k = 0; k < method2.headers.Length; k++)
{
SoapHeaderMapping mapping = new SoapHeaderMapping();
SoapReflectedHeader header = method2.headers[k];
mapping.memberInfo = header.memberInfo;
mapping.repeats = header.repeats;
mapping.custom = header.custom;
mapping.direction = header.direction;
mapping.headerType = header.headerType;
if ((mapping.direction & SoapHeaderDirection.In) != 0)
{
list5.Add(mapping);
}
if ((mapping.direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0)
{
list6.Add(mapping);
}
}
method3.inHeaderMappings = (SoapHeaderMapping[]) list5.ToArray(typeof(SoapHeaderMapping));
if (method3.outHeaderSerializer != null)
{
method3.outHeaderMappings = (SoapHeaderMapping[]) list6.ToArray(typeof(SoapHeaderMapping));
}
this.methods.Add(method2.name, method3);
}
}
internal SoapClientType(Type type) {
this.binding = WebServiceBindingReflector.GetAttribute(type);
if (this.binding == null) throw new InvalidOperationException(Res.GetString(Res.WebClientBindingAttributeRequired));
// Note: Service namespace is taken from WebserviceBindingAttribute and not WebserviceAttribute because
// the generated proxy does not have a WebServiceAttribute; however all have a WebServiceBindingAttribute.
serviceNamespace = binding.Namespace;
serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
ArrayList soapMethodList = new ArrayList();
ArrayList mappings = new ArrayList();
GenerateXmlMappings(type, soapMethodList, serviceNamespace, serviceDefaultIsEncoded, mappings);
XmlMapping[] xmlMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));
TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", type) : null;
if (Tracing.On) Tracing.Enter(Tracing.TraceId(Res.TraceCreateSerializer), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", xmlMappings, type));
XmlSerializer[] serializers = XmlSerializer.FromMappings(xmlMappings, type);
if (Tracing.On) Tracing.Exit(Tracing.TraceId(Res.TraceCreateSerializer), caller);
SoapExtensionTypeElementCollection extensionTypes = WebServicesSection.Current.SoapExtensionTypes;
ArrayList highPri = new ArrayList();
ArrayList lowPri = new ArrayList();
for (int i = 0; i < extensionTypes.Count; i++) {
SoapExtensionTypeElement element = extensionTypes[i];
SoapReflectedExtension extension = new SoapReflectedExtension(extensionTypes[i].Type, null, extensionTypes[i].Priority);
if (extensionTypes[i].Group == PriorityGroup.High)
highPri.Add(extension);
else
lowPri.Add(extension);
}
HighPriExtensions = (SoapReflectedExtension[]) highPri.ToArray(typeof(SoapReflectedExtension));
LowPriExtensions = (SoapReflectedExtension[]) lowPri.ToArray(typeof(SoapReflectedExtension));
Array.Sort(HighPriExtensions);
Array.Sort(LowPriExtensions);
HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, HighPriExtensions);
LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, LowPriExtensions);
int count = 0;
for (int i = 0; i < soapMethodList.Count; i++) {
SoapReflectedMethod soapMethod = (SoapReflectedMethod)soapMethodList[i];
SoapClientMethod clientMethod = new SoapClientMethod();
clientMethod.parameterSerializer = serializers[count++];
if (soapMethod.responseMappings != null) clientMethod.returnSerializer = serializers[count++];
clientMethod.inHeaderSerializer = serializers[count++];
if (soapMethod.outHeaderMappings != null) clientMethod.outHeaderSerializer = serializers[count++];
clientMethod.action = soapMethod.action;
clientMethod.oneWay = soapMethod.oneWay;
clientMethod.rpc = soapMethod.rpc;
clientMethod.use = soapMethod.use;
clientMethod.paramStyle = soapMethod.paramStyle;
clientMethod.methodInfo = soapMethod.methodInfo;
clientMethod.extensions = soapMethod.extensions;
clientMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(clientMethod.methodInfo, soapMethod.extensions);
ArrayList inHeaders = new ArrayList();
ArrayList outHeaders = new ArrayList();
for (int j = 0; j < soapMethod.headers.Length; j++) {
SoapHeaderMapping mapping = new SoapHeaderMapping();
SoapReflectedHeader soapHeader = soapMethod.headers[j];
mapping.memberInfo = soapHeader.memberInfo;
mapping.repeats = soapHeader.repeats;
mapping.custom = soapHeader.custom;
mapping.direction = soapHeader.direction;
mapping.headerType = soapHeader.headerType;
if ((mapping.direction & SoapHeaderDirection.In) != 0)
inHeaders.Add(mapping);
if ((mapping.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
outHeaders.Add(mapping);
}
clientMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping));
if (clientMethod.outHeaderSerializer != null)
clientMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping));
methods.Add(soapMethod.name, clientMethod);
}
}
private object[] ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, bool asyncCall)
{
int bufferSize;
SoapClientMethod method = message.Method;
HttpWebResponse response2 = response as HttpWebResponse;
int num = (response2 != null) ? ((int)response2.StatusCode) : -1;
if (((num >= 300) && (num != 500)) && (num != 400))
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(response2, responseStream), null, WebExceptionStatus.ProtocolError, response2);
}
message.Headers.Clear();
message.SetStream(responseStream);
message.InitExtensionStreamChain(message.initializedExtensions);
message.SetStage(SoapMessageStage.BeforeDeserialize);
message.ContentType = response.ContentType;
message.ContentEncoding = response.Headers["Content-Encoding"];
message.RunExtensions(message.initializedExtensions, false);
if (method.oneWay && ((response2 == null) || (response2.StatusCode != HttpStatusCode.InternalServerError)))
{
return(new object[0]);
}
bool flag = ContentType.IsSoap(message.ContentType);
if (!flag || ((flag && (response2 != null)) && (response2.ContentLength == 0L)))
{
if (num == 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(response2, responseStream), null, WebExceptionStatus.ProtocolError, response2);
}
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebResponseContent", new object[] { message.ContentType, this.HttpContentType }) + Environment.NewLine + RequestResponseUtils.CreateResponseExceptionString(response, responseStream));
}
if (message.Exception != null)
{
throw message.Exception;
}
if (asyncCall || (response2 == null))
{
bufferSize = 0x200;
}
else
{
bufferSize = RequestResponseUtils.GetBufferSize((int)response2.ContentLength);
}
XmlReader readerForMessage = this.GetReaderForMessage(message, bufferSize);
if (readerForMessage == null)
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebNullReaderForMessage"));
}
readerForMessage.MoveToContent();
int depth = readerForMessage.Depth;
string encodingNs = this.EncodingNs;
string namespaceURI = readerForMessage.NamespaceURI;
if ((namespaceURI == null) || (namespaceURI.Length == 0))
{
readerForMessage.ReadStartElement("Envelope");
}
else if (readerForMessage.NamespaceURI == "http://schemas.xmlsoap.org/soap/envelope/")
{
readerForMessage.ReadStartElement("Envelope", "http://schemas.xmlsoap.org/soap/envelope/");
}
else
{
if (readerForMessage.NamespaceURI != "http://www.w3.org/2003/05/soap-envelope")
{
throw new SoapException(System.Web.Services.Res.GetString("WebInvalidEnvelopeNamespace", new object[] { namespaceURI, this.EnvelopeNs }), SoapException.VersionMismatchFaultCode);
}
readerForMessage.ReadStartElement("Envelope", "http://www.w3.org/2003/05/soap-envelope");
}
readerForMessage.MoveToContent();
new SoapHeaderHandling().ReadHeaders(readerForMessage, method.outHeaderSerializer, message.Headers, method.outHeaderMappings, SoapHeaderDirection.Fault | SoapHeaderDirection.Out, namespaceURI, (method.use == SoapBindingUse.Encoded) ? encodingNs : null, false);
readerForMessage.MoveToContent();
readerForMessage.ReadStartElement("Body", namespaceURI);
readerForMessage.MoveToContent();
if (readerForMessage.IsStartElement("Fault", namespaceURI))
{
message.Exception = this.ReadSoapException(readerForMessage);
}
else if (method.oneWay)
{
readerForMessage.Skip();
message.SetParameterValues(new object[0]);
}
else
{
TraceMethod caller = Tracing.On ? new TraceMethod(this, "ReadResponse", new object[0]) : null;
bool flag2 = method.use == SoapBindingUse.Encoded;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceReadResponse"), caller, new TraceMethod(method.returnSerializer, "Deserialize", new object[] { readerForMessage, flag2 ? encodingNs : null }));
}
if (!flag2 && (WebServicesSection.Current.SoapEnvelopeProcessing.IsStrict || Tracing.On))
{
XmlDeserializationEvents events = Tracing.On ? Tracing.GetDeserializationEvents() : RuntimeUtils.GetDeserializationEvents();
message.SetParameterValues((object[])method.returnSerializer.Deserialize(readerForMessage, null, events));
}
else
{
message.SetParameterValues((object[])method.returnSerializer.Deserialize(readerForMessage, flag2 ? encodingNs : null));
}
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceReadResponse"), caller);
}
}
while ((depth < readerForMessage.Depth) && readerForMessage.Read())
{
}
if (readerForMessage.NodeType == XmlNodeType.EndElement)
{
readerForMessage.Read();
}
message.SetStage(SoapMessageStage.AfterDeserialize);
message.RunExtensions(message.initializedExtensions, false);
SoapHeaderHandling.SetHeaderMembers(message.Headers, this, method.outHeaderMappings, SoapHeaderDirection.Fault | SoapHeaderDirection.Out, true);
if (message.Exception != null)
{
throw message.Exception;
}
return(message.GetParameterValues());
}