internal static void GenerateXmlMappings(Type type, ArrayList soapMethodList, string serviceNamespace, bool serviceDefaultIsEncoded, ArrayList mappings) { LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(BindingFlags.Public | BindingFlags.Instance), LogicalMethodTypes.Sync); SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded); XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded); WebMethodReflector.IncludeTypes(methodInfos, xmlImporter); SoapReflector.IncludeTypes(methodInfos, soapImporter); 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); } } }
public SoapServerMethod(Type serverType, LogicalMethodInfo methodInfo) { this.methodInfo = methodInfo; // // Set up the XmlImporter, the SoapImporter, and acquire // the ServiceAttribute on the serverType for use in // creating a SoapReflectedMethod. // WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(serverType); string serviceNamespace = serviceAttribute.Namespace; bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(serverType); SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded); XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded); // // Add some types relating to the methodInfo into the two importers // SoapReflector.IncludeTypes(methodInfo, soapImporter); WebMethodReflector.IncludeTypes(methodInfo, xmlImporter); // // Create a SoapReflectedMethod by reflecting on the // LogicalMethodInfo passed to us. // SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, false, xmlImporter, soapImporter, serviceNamespace); // // Most of the fields in this class are ----ed in from the reflected information // ImportReflectedMethod(soapMethod); ImportSerializers(soapMethod, GetServerTypeEvidence(serverType)); ImportHeaderSerializers(soapMethod); }
static string GetHeaderElementName(Type headerType) { XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(null, false); XmlTypeMapping mapping = importer.ImportTypeMapping(headerType); return(mapping.ElementName); }
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 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, 0x400); if (writerForMessage == null) { throw new InvalidOperationException(System.Web.Services.Res.GetString("WebNullWriterForMessage")); } writerForMessage.WriteStartDocument(); writerForMessage.WriteStartElement("soap", "Envelope", envelopeNs); writerForMessage.WriteAttributeString("xmlns", "soap", null, envelopeNs); if (isEncoded) { writerForMessage.WriteAttributeString("xmlns", "soapenc", null, encodingNs); writerForMessage.WriteAttributeString("xmlns", "tns", null, this.clientType.serviceNamespace); writerForMessage.WriteAttributeString("xmlns", "types", null, SoapReflector.GetEncodedNamespace(this.clientType.serviceNamespace, this.clientType.serviceDefaultIsEncoded)); } writerForMessage.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance"); writerForMessage.WriteAttributeString("xmlns", "xsd", 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", null, encodingNs); } object[] parameterValues = message.GetParameterValues(); TraceMethod caller = Tracing.On ? new TraceMethod(this, "Serialize", new object[0]) : null; if (Tracing.On) { object[] args = new object[4]; args[0] = writerForMessage; args[1] = parameterValues; args[3] = isEncoded ? encodingNs : null; Tracing.Enter(Tracing.TraceId("TraceWriteRequest"), caller, new TraceMethod(method.parameterSerializer, "Serialize", args)); } method.parameterSerializer.Serialize(writerForMessage, parameterValues, null, isEncoded ? encodingNs : 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); }
public SoapServerMethod(Type serverType, LogicalMethodInfo methodInfo) { this.methodInfo = methodInfo; string defaultNs = WebServiceReflector.GetAttribute(serverType).Namespace; bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(serverType); SoapReflectionImporter importer = SoapReflector.CreateSoapImporter(defaultNs, serviceDefaultIsEncoded); XmlReflectionImporter importer2 = SoapReflector.CreateXmlImporter(defaultNs, serviceDefaultIsEncoded); SoapReflector.IncludeTypes(methodInfo, importer); WebMethodReflector.IncludeTypes(methodInfo, importer2); SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, false, importer2, importer, defaultNs); this.ImportReflectedMethod(soapMethod); this.ImportSerializers(soapMethod, this.GetServerTypeEvidence(serverType)); this.ImportHeaderSerializers(soapMethod); }
public static bool GenerateXmlMappings(Type type, ArrayList mappings) { if (!typeof(SoapHttpClientProtocol).IsAssignableFrom(type)) { return(false); } WebServiceBindingAttribute attribute = WebServiceBindingReflector.GetAttribute(type); if (attribute == null) { throw new InvalidOperationException(Res.GetString("WebClientBindingAttributeRequired")); } string serviceNamespace = attribute.Namespace; bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type); ArrayList soapMethodList = new ArrayList(); SoapClientType.GenerateXmlMappings(type, soapMethodList, serviceNamespace, serviceDefaultIsEncoded, mappings); return(true); }
/// <include file='doc\ClientProtocol.uex' path='docs/doc[@for="HttpWebClientProtocol.GenerateXmlMappings"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public static bool GenerateXmlMappings(Type type, ArrayList mappings) { if (typeof(SoapHttpClientProtocol).IsAssignableFrom(type)) { WebServiceBindingAttribute binding = WebServiceBindingReflector.GetAttribute(type); if (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. string serviceNamespace = binding.Namespace; bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type); ArrayList soapMethodList = new ArrayList(); SoapClientType.GenerateXmlMappings(type, soapMethodList, serviceNamespace, serviceDefaultIsEncoded, mappings); return(true); } return(false); }
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); }
internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos) { if (methodInfos.Length == 0) { return(new object[0]); } WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(methodInfos); bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos)); XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(serviceAttribute.Namespace, serviceDefaultIsEncoded); WebMethodReflector.IncludeTypes(methodInfos, importer); ArrayList mappings = new ArrayList(); for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; Type type = methodInfo.ReturnType; if (IsSupported(type)) { XmlAttributes a = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); XmlTypeMapping mapping = importer.ImportTypeMapping(type, a.XmlRoot); mappings.Add(mapping); } } XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping))); object[] initializers = new object[methodInfos.Length]; int count = 0; for (int i = 0; i < initializers.Length; i++) { if (IsSupported(methodInfos[i].ReturnType)) { initializers[i] = serializers[count++]; } } return(initializers); }
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 override void WriteReturns(object[] returnValues, Stream outputStream) { if (!this.serverMethod.oneWay) { bool isEncoded = this.serverMethod.use == SoapBindingUse.Encoded; SoapHeaderHandling.EnsureHeadersUnderstood(this.message.Headers); this.message.Headers.Clear(); SoapHeaderHandling.GetHeaderMembers(this.message.Headers, this.Target, this.serverMethod.outHeaderMappings, SoapHeaderDirection.Out, false); if (this.message.allExtensions != null) { this.message.SetExtensionStream(new SoapExtensionStream()); } this.message.InitExtensionStreamChain(this.message.allExtensions); this.message.SetStage(SoapMessageStage.BeforeSerialize); this.message.ContentType = ContentType.Compose(this.helper.HttpContentType, Encoding.UTF8); this.message.SetParameterValues(returnValues); this.message.RunExtensions(this.message.allExtensions, true); this.message.SetStream(outputStream); base.Response.ContentType = this.message.ContentType; if ((this.message.ContentEncoding != null) && (this.message.ContentEncoding.Length > 0)) { base.Response.AppendHeader("Content-Encoding", this.message.ContentEncoding); } XmlWriter writerForMessage = this.GetWriterForMessage(this.message, 0x400); if (writerForMessage == null) { throw new InvalidOperationException(System.Web.Services.Res.GetString("WebNullWriterForMessage")); } writerForMessage.WriteStartDocument(); writerForMessage.WriteStartElement("soap", "Envelope", this.helper.EnvelopeNs); writerForMessage.WriteAttributeString("xmlns", "soap", null, this.helper.EnvelopeNs); if (isEncoded) { writerForMessage.WriteAttributeString("xmlns", "soapenc", null, this.helper.EncodingNs); writerForMessage.WriteAttributeString("xmlns", "tns", null, this.serverType.serviceNamespace); writerForMessage.WriteAttributeString("xmlns", "types", null, SoapReflector.GetEncodedNamespace(this.serverType.serviceNamespace, this.serverType.serviceDefaultIsEncoded)); } if (this.serverMethod.rpc && (this.version == SoapProtocolVersion.Soap12)) { writerForMessage.WriteAttributeString("xmlns", "rpc", null, "http://www.w3.org/2003/05/soap-rpc"); } writerForMessage.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance"); writerForMessage.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema"); SoapHeaderHandling.WriteHeaders(writerForMessage, this.serverMethod.outHeaderSerializer, this.message.Headers, this.serverMethod.outHeaderMappings, SoapHeaderDirection.Out, isEncoded, this.serverType.serviceNamespace, this.serverType.serviceDefaultIsEncoded, this.helper.EnvelopeNs); writerForMessage.WriteStartElement("Body", this.helper.EnvelopeNs); if (isEncoded && (this.version != SoapProtocolVersion.Soap12)) { writerForMessage.WriteAttributeString("soap", "encodingStyle", null, this.helper.EncodingNs); } TraceMethod caller = Tracing.On ? new TraceMethod(this, "WriteReturns", new object[0]) : null; if (Tracing.On) { object[] args = new object[4]; args[0] = writerForMessage; args[1] = returnValues; args[3] = isEncoded ? this.helper.EncodingNs : null; Tracing.Enter(Tracing.TraceId("TraceWriteResponse"), caller, new TraceMethod(this.serverMethod.returnSerializer, "Serialize", args)); } this.serverMethod.returnSerializer.Serialize(writerForMessage, returnValues, null, isEncoded ? this.helper.EncodingNs : null); if (Tracing.On) { Tracing.Exit(Tracing.TraceId("TraceWriteResponse"), caller); } writerForMessage.WriteEndElement(); writerForMessage.WriteEndElement(); writerForMessage.Flush(); this.message.SetStage(SoapMessageStage.AfterSerialize); this.message.RunExtensions(this.message.allExtensions, true); } }
public SoapServerType(Type type, WebServiceProtocols protocolsSupported) : base(type) { this.methods = new Hashtable(); this.duplicateMethods = new Hashtable(); this.protocolsSupported = protocolsSupported; bool flag = (protocolsSupported & WebServiceProtocols.HttpSoap) != WebServiceProtocols.Unknown; LogicalMethodInfo[] methods = WebMethodReflector.GetMethods(type); ArrayList list = new ArrayList(); WebServiceAttribute attribute = WebServiceReflector.GetAttribute(type); object soapServiceAttribute = SoapReflector.GetSoapServiceAttribute(type); this.routingOnSoapAction = SoapReflector.GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.SoapAction; this.serviceNamespace = attribute.Namespace; this.serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type); SoapReflectionImporter importer = SoapReflector.CreateSoapImporter(this.serviceNamespace, this.serviceDefaultIsEncoded); XmlReflectionImporter importer2 = SoapReflector.CreateXmlImporter(this.serviceNamespace, this.serviceDefaultIsEncoded); SoapReflector.IncludeTypes(methods, importer); WebMethodReflector.IncludeTypes(methods, importer2); SoapReflectedMethod[] methodArray = new SoapReflectedMethod[methods.Length]; SoapExtensionTypeElementCollection soapExtensionTypes = WebServicesSection.Current.SoapExtensionTypes; ArrayList list2 = new ArrayList(); ArrayList list3 = new ArrayList(); for (int i = 0; i < soapExtensionTypes.Count; i++) { SoapExtensionTypeElement element = soapExtensionTypes[i]; if (element != null) { SoapReflectedExtension extension = new SoapReflectedExtension(element.Type, null, element.Priority); if (element.Group == PriorityGroup.High) { list2.Add(extension); } else { list3.Add(extension); } } } this.HighPriExtensions = (SoapReflectedExtension[])list2.ToArray(typeof(SoapReflectedExtension)); this.LowPriExtensions = (SoapReflectedExtension[])list3.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); for (int j = 0; j < methods.Length; j++) { LogicalMethodInfo methodInfo = methods[j]; SoapReflectedMethod method = SoapReflector.ReflectMethod(methodInfo, false, importer2, importer, attribute.Namespace); list.Add(method.requestMappings); if (method.responseMappings != null) { list.Add(method.responseMappings); } list.Add(method.inHeaderMappings); if (method.outHeaderMappings != null) { list.Add(method.outHeaderMappings); } methodArray[j] = method; } XmlMapping[] mappings = (XmlMapping[])list.ToArray(typeof(XmlMapping)); TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", new object[] { type, protocolsSupported }) : null; if (Tracing.On) { Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappings, base.Evidence })); } XmlSerializer[] serializerArray = null; if (AppDomain.CurrentDomain.IsHomogenous) { serializerArray = XmlSerializer.FromMappings(mappings); } else { serializerArray = XmlSerializer.FromMappings(mappings, base.Evidence); } if (Tracing.On) { Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller); } int num3 = 0; for (int k = 0; k < methodArray.Length; k++) { SoapServerMethod method3 = new SoapServerMethod(); SoapReflectedMethod method4 = methodArray[k]; method3.parameterSerializer = serializerArray[num3++]; if (method4.responseMappings != null) { method3.returnSerializer = serializerArray[num3++]; } method3.inHeaderSerializer = serializerArray[num3++]; if (method4.outHeaderMappings != null) { method3.outHeaderSerializer = serializerArray[num3++]; } method3.methodInfo = method4.methodInfo; method3.action = method4.action; method3.extensions = method4.extensions; method3.extensionInitializers = SoapReflectedExtension.GetInitializers(method3.methodInfo, method4.extensions); method3.oneWay = method4.oneWay; method3.rpc = method4.rpc; method3.use = method4.use; method3.paramStyle = method4.paramStyle; method3.wsiClaims = (method4.binding == null) ? WsiProfiles.None : method4.binding.ConformsTo; ArrayList list4 = new ArrayList(); ArrayList list5 = new ArrayList(); for (int m = 0; m < method4.headers.Length; m++) { SoapHeaderMapping mapping = new SoapHeaderMapping(); SoapReflectedHeader header = method4.headers[m]; 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) { list4.Add(mapping); } else if (mapping.direction == SoapHeaderDirection.Out) { list5.Add(mapping); } else { list4.Add(mapping); list5.Add(mapping); } } method3.inHeaderMappings = (SoapHeaderMapping[])list4.ToArray(typeof(SoapHeaderMapping)); if (method3.outHeaderSerializer != null) { method3.outHeaderMappings = (SoapHeaderMapping[])list5.ToArray(typeof(SoapHeaderMapping)); } if ((flag && !this.routingOnSoapAction) && method4.requestElementName.IsEmpty) { throw new SoapException(System.Web.Services.Res.GetString("TheMethodDoesNotHaveARequestElementEither1", new object[] { method3.methodInfo.Name }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/")); } if (this.methods[method4.action] == null) { this.methods[method4.action] = method3; } else { if (flag && this.routingOnSoapAction) { SoapServerMethod method5 = (SoapServerMethod)this.methods[method4.action]; throw new SoapException(System.Web.Services.Res.GetString("TheMethodsAndUseTheSameSoapActionWhenTheService3", new object[] { method3.methodInfo.Name, method5.methodInfo.Name, method4.action }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/")); } this.duplicateMethods[method4.action] = method3; } if (this.methods[method4.requestElementName] == null) { this.methods[method4.requestElementName] = method3; } else { if (flag && !this.routingOnSoapAction) { SoapServerMethod method6 = (SoapServerMethod)this.methods[method4.requestElementName]; throw new SoapException(System.Web.Services.Res.GetString("TheMethodsAndUseTheSameRequestElementXmlns4", new object[] { method3.methodInfo.Name, method6.methodInfo.Name, method4.requestElementName.Name, method4.requestElementName.Namespace }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/")); } this.duplicateMethods[method4.requestElementName] = 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); } }
internal SoapServerType(Type type, ProtocolsEnum versionsSupported) : base(type) { this.versionsSupported = versionsSupported; bool soap11 = (versionsSupported & ProtocolsEnum.HttpSoap) != 0; bool soap12 = (versionsSupported & ProtocolsEnum.HttpSoap12) != 0; LogicalMethodInfo[] methodInfos = WebMethodReflector.GetMethods(type); ArrayList mappings = new ArrayList(); WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(type); object soapServiceAttribute = SoapReflector.GetSoapServiceAttribute(type); routingOnSoapAction = SoapReflector.GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.SoapAction; serviceNamespace = serviceAttribute.Namespace; serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type); SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded); XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded); SoapReflector.IncludeTypes(methodInfos, soapImporter); WebMethodReflector.IncludeTypes(methodInfos, xmlImporter); SoapReflectedMethod[] soapMethods = new SoapReflectedMethod[methodInfos.Length]; 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, false, xmlImporter, soapImporter, serviceAttribute.Namespace); mappings.Add(soapMethod.requestMappings); if (soapMethod.responseMappings != null) { mappings.Add(soapMethod.responseMappings); } mappings.Add(soapMethod.inHeaderMappings); if (soapMethod.outHeaderMappings != null) { mappings.Add(soapMethod.outHeaderMappings); } soapMethods[i] = soapMethod; } XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping))); int count = 0; for (int i = 0; i < soapMethods.Length; i++) { SoapServerMethod serverMethod = new SoapServerMethod(); SoapReflectedMethod soapMethod = soapMethods[i]; serverMethod.parameterSerializer = serializers[count++]; if (soapMethod.responseMappings != null) { serverMethod.returnSerializer = serializers[count++]; } serverMethod.inHeaderSerializer = serializers[count++]; if (soapMethod.outHeaderMappings != null) { serverMethod.outHeaderSerializer = serializers[count++]; } serverMethod.methodInfo = soapMethod.methodInfo; serverMethod.action = soapMethod.action; serverMethod.extensions = soapMethod.extensions; serverMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(serverMethod.methodInfo, soapMethod.extensions); serverMethod.oneWay = soapMethod.oneWay; serverMethod.rpc = soapMethod.rpc; serverMethod.use = soapMethod.use; serverMethod.paramStyle = soapMethod.paramStyle; 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) { inHeaders.Add(mapping); } else if (mapping.direction == SoapHeaderDirection.Out) { outHeaders.Add(mapping); } else { inHeaders.Add(mapping); outHeaders.Add(mapping); } } serverMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping)); if (serverMethod.outHeaderSerializer != null) { serverMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping)); } // check feasibility of routing on request element for soap 1.1 if (soap11 && !routingOnSoapAction && soapMethod.requestElementName.IsEmpty) { throw new SoapException(Res.GetString(Res.TheMethodDoesNotHaveARequestElementEither1, serverMethod.methodInfo.Name), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace)); } // we can lookup methods by action or request element if (methods[soapMethod.action] == null) { methods[soapMethod.action] = serverMethod; } else { // duplicate soap actions not allowed in soap 1.1 if we're routing on soap action if (soap11 && routingOnSoapAction) { SoapServerMethod duplicateMethod = (SoapServerMethod)methods[soapMethod.action]; throw new SoapException(Res.GetString(Res.TheMethodsAndUseTheSameSoapActionWhenTheService3, serverMethod.methodInfo.Name, duplicateMethod.methodInfo.Name, soapMethod.action), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace)); } duplicateMethods[soapMethod.action] = serverMethod; } if (methods[soapMethod.requestElementName] == null) { methods[soapMethod.requestElementName] = serverMethod; } else { // duplicate request elements not allowed in soap 1.1 if we're routing on request element if (soap11 && !routingOnSoapAction) { SoapServerMethod duplicateMethod = (SoapServerMethod)methods[soapMethod.requestElementName]; throw new SoapException(Res.GetString(Res.TheMethodsAndUseTheSameRequestElementXmlns4, serverMethod.methodInfo.Name, duplicateMethod.methodInfo.Name, soapMethod.requestElementName.Name, soapMethod.requestElementName.Namespace), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace)); } duplicateMethods[soapMethod.requestElementName] = serverMethod; } } }
public static void WriteHeaders(XmlWriter writer, XmlSerializer serializer, SoapHeaderCollection headers, SoapHeaderMapping[] mappings, SoapHeaderDirection direction, bool isEncoded, string defaultNS, bool serviceDefaultIsEncoded, string envelopeNS) { if (headers.Count != 0) { SoapProtocolVersion version; string str; writer.WriteStartElement("Header", envelopeNS); if (envelopeNS == "http://www.w3.org/2003/05/soap-envelope") { version = SoapProtocolVersion.Soap12; str = "http://www.w3.org/2003/05/soap-encoding"; } else { version = SoapProtocolVersion.Soap11; str = "http://schemas.xmlsoap.org/soap/encoding/"; } int num = 0; ArrayList list = new ArrayList(); SoapHeader[] o = new SoapHeader[mappings.Length]; bool[] flagArray = new bool[o.Length]; for (int i = 0; i < headers.Count; i++) { SoapHeader header = headers[i]; if (header != null) { header.version = version; if (header is SoapUnknownHeader) { list.Add(header); num++; } else { int num3; if (((num3 = FindMapping(mappings, header, direction)) >= 0) && !flagArray[num3]) { o[num3] = header; flagArray[num3] = true; } else { list.Add(header); } } } } int num4 = list.Count - num; if (isEncoded && (num4 > 0)) { SoapHeader[] array = new SoapHeader[mappings.Length + num4]; o.CopyTo(array, 0); int length = mappings.Length; for (int k = 0; k < list.Count; k++) { if (!(list[k] is SoapUnknownHeader)) { array[length++] = (SoapHeader)list[k]; } } o = array; } TraceMethod caller = Tracing.On ? new TraceMethod(typeof(SoapHeaderHandling), "WriteHeaders", new object[0]) : null; if (Tracing.On) { object[] args = new object[5]; args[0] = writer; args[1] = o; args[3] = isEncoded ? str : null; args[4] = "h_"; Tracing.Enter(Tracing.TraceId("TraceWriteHeaders"), caller, new TraceMethod(serializer, "Serialize", args)); } serializer.Serialize(writer, o, null, isEncoded ? str : null, "h_"); if (Tracing.On) { Tracing.Exit(Tracing.TraceId("TraceWriteHeaders"), caller); } foreach (SoapHeader header2 in list) { if (header2 is SoapUnknownHeader) { SoapUnknownHeader header3 = (SoapUnknownHeader)header2; if (header3.Element != null) { header3.Element.WriteTo(writer); } } else if (!isEncoded) { string literalNamespace = SoapReflector.GetLiteralNamespace(defaultNS, serviceDefaultIsEncoded); XmlSerializer target = new XmlSerializer(header2.GetType(), literalNamespace); if (Tracing.On) { Tracing.Enter(Tracing.TraceId("TraceWriteHeaders"), caller, new TraceMethod(target, "Serialize", new object[] { writer, header2 })); } target.Serialize(writer, header2); if (Tracing.On) { Tracing.Exit(Tracing.TraceId("TraceWriteHeaders"), caller); } } } for (int j = 0; j < headers.Count; j++) { SoapHeader header4 = headers[j]; if (header4 != null) { header4.version = SoapProtocolVersion.Default; } } writer.WriteEndElement(); writer.Flush(); } }
public static void WriteHeaders(XmlWriter writer, XmlSerializer serializer, SoapHeaderCollection headers, SoapHeaderMapping[] mappings, SoapHeaderDirection direction, bool isEncoded, string defaultNS, bool serviceDefaultIsEncoded, string envelopeNS) { if (headers.Count == 0) { return; } writer.WriteStartElement(Soap.Element.Header, envelopeNS); SoapProtocolVersion version; string encodingStyle; if (envelopeNS == Soap12.Namespace) { version = SoapProtocolVersion.Soap12; encodingStyle = Soap12.Encoding; } else { version = SoapProtocolVersion.Soap11; encodingStyle = Soap.Encoding; } int unknownHeaderCount = 0; ArrayList otherHeaders = new ArrayList(); SoapHeader[] headerArray = new SoapHeader[mappings.Length]; bool[] headerSet = new bool[headerArray.Length]; for (int i = 0; i < headers.Count; i++) { SoapHeader header = headers[i]; if (header == null) { continue; } int headerPosition; header.version = version; if (header is SoapUnknownHeader) { otherHeaders.Add(header); unknownHeaderCount++; } else if ((headerPosition = FindMapping(mappings, header, direction)) >= 0 && !headerSet[headerPosition]) { headerArray[headerPosition] = header; headerSet[headerPosition] = true; } else { otherHeaders.Add(header); } } int otherHeaderCount = otherHeaders.Count - unknownHeaderCount; if (isEncoded && otherHeaderCount > 0) { SoapHeader[] newHeaderArray = new SoapHeader[mappings.Length + otherHeaderCount]; headerArray.CopyTo(newHeaderArray, 0); // fill in the non-statically known headers (otherHeaders) starting after the statically-known ones int count = mappings.Length; for (int i = 0; i < otherHeaders.Count; i++) { if (!(otherHeaders[i] is SoapUnknownHeader)) { newHeaderArray[count++] = (SoapHeader)otherHeaders[i]; } } headerArray = newHeaderArray; } TraceMethod caller = Tracing.On ? new TraceMethod(typeof(SoapHeaderHandling), "WriteHeaders") : null; if (Tracing.On) { Tracing.Enter(Tracing.TraceId(Res.TraceWriteHeaders), caller, new TraceMethod(serializer, "Serialize", writer, headerArray, null, isEncoded ? encodingStyle : null, "h_")); } serializer.Serialize(writer, headerArray, null, isEncoded ? encodingStyle : null, "h_"); if (Tracing.On) { Tracing.Exit(Tracing.TraceId(Res.TraceWriteHeaders), caller); } foreach (SoapHeader header in otherHeaders) { if (header is SoapUnknownHeader) { SoapUnknownHeader unknown = (SoapUnknownHeader)header; if (unknown.Element != null) { unknown.Element.WriteTo(writer); } } else if (!isEncoded) // encoded headers already appended to members mapping { string ns = SoapReflector.GetLiteralNamespace(defaultNS, serviceDefaultIsEncoded); XmlSerializer headerSerializer = new XmlSerializer(header.GetType(), ns); if (Tracing.On) { Tracing.Enter(Tracing.TraceId(Res.TraceWriteHeaders), caller, new TraceMethod(headerSerializer, "Serialize", writer, header)); } headerSerializer.Serialize(writer, header); if (Tracing.On) { Tracing.Exit(Tracing.TraceId(Res.TraceWriteHeaders), caller); } } } // reset the soap version for (int i = 0; i < headers.Count; i++) { SoapHeader header = headers[i]; if (header != null) { header.version = SoapProtocolVersion.Default; } } writer.WriteEndElement(); writer.Flush(); }
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 static object[] GetInitializers(LogicalMethodInfo[] methodInfos) { if (methodInfos.Length == 0) { return(new object[0]); } WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(methodInfos); bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos)); XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(serviceAttribute.Namespace, serviceDefaultIsEncoded); WebMethodReflector.IncludeTypes(methodInfos, importer); ArrayList mappings = new ArrayList(); bool[] supported = new bool[methodInfos.Length]; for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; Type type = methodInfo.ReturnType; if (IsSupported(type) && HttpServerProtocol.AreUrlParametersSupported(methodInfo)) { XmlAttributes a = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); XmlTypeMapping mapping = importer.ImportTypeMapping(type, a.XmlRoot); mapping.SetKey(methodInfo.GetKey() + ":Return"); mappings.Add(mapping); supported[i] = true; } } if (mappings.Count == 0) { return(new object[0]); } XmlMapping[] xmlMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping)); Evidence evidence = GetEvidenceForType(methodInfos[0].DeclaringType); TraceMethod caller = Tracing.On ? new TraceMethod(typeof(XmlReturn), "GetInitializers", methodInfos) : null; if (Tracing.On) { Tracing.Enter(Tracing.TraceId(Res.TraceCreateSerializer), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", xmlMappings, evidence)); } XmlSerializer[] serializers = null; if (AppDomain.CurrentDomain.IsHomogenous) { serializers = XmlSerializer.FromMappings(xmlMappings); } else { #pragma warning disable 618 // If we're in a non-homogenous domain, legacy CAS mode is enabled, so passing through evidence will not fail serializers = XmlSerializer.FromMappings(xmlMappings, evidence); #pragma warning restore 618 } if (Tracing.On) { Tracing.Exit(Tracing.TraceId(Res.TraceCreateSerializer), caller); } object[] initializers = new object[methodInfos.Length]; int count = 0; for (int i = 0; i < initializers.Length; i++) { if (supported[i]) { initializers[i] = serializers[count++]; } } return(initializers); }
internal static void WriteHeaders(XmlWriter writer, XmlSerializer serializer, SoapHeaderCollection headers, SoapHeaderMapping[] mappings, SoapHeaderDirection direction, bool isEncoded, string defaultNs, bool serviceDefaultIsEncoded, string envelopeNs) { if (headers.Count == 0) { return; } if (isEncoded && writer is XmlSpecialTextWriter) { ((XmlSpecialTextWriter)writer).EncodeIds = true; } writer.WriteStartElement(Soap.Header, envelopeNs); // SOAP12: always soap 1.1, not using encodingStyle; //SoapProtocolVersion version; SoapProtocolVersion version = SoapProtocolVersion.Soap11; // SOAP12: not using encodingStyle /*string encodingStyle; * if (envelopeNs == Soap12.Namespace) { * version = SoapProtocolVersion.Soap12; * encodingStyle = Soap12.Encoding; * } * else { * version = SoapProtocolVersion.Soap11; * encodingStyle = Soap.Encoding; * }*/ int unknownHeaderCount = 0; ArrayList otherHeaders = new ArrayList(); SoapHeader[] headerArray = new SoapHeader[mappings.Length]; bool[] headerSet = new bool[headerArray.Length]; for (int i = 0; i < headers.Count; i++) { SoapHeader header = headers[i]; if (header == null) { continue; } int headerPosition; header.version = version; if (header is SoapUnknownHeader) { otherHeaders.Add(header); unknownHeaderCount++; } else if ((headerPosition = FindMapping(mappings, header, direction)) >= 0 && !headerSet[headerPosition]) { headerArray[headerPosition] = header; headerSet[headerPosition] = true; } else { otherHeaders.Add(header); } } int otherHeaderCount = otherHeaders.Count - unknownHeaderCount; if (isEncoded && otherHeaderCount > 0) { SoapHeader[] newHeaderArray = new SoapHeader[mappings.Length + otherHeaderCount]; headerArray.CopyTo(newHeaderArray, 0); // fill in the non-statically known headers (otherHeaders) starting after the statically-known ones int count = mappings.Length; for (int i = 0; i < otherHeaders.Count; i++) { if (!(otherHeaders[i] is SoapUnknownHeader)) { newHeaderArray[count++] = (SoapHeader)otherHeaders[i]; } } headerArray = newHeaderArray; } // SOAP12: not using encodingStyle //serializer.Serialize(writer, headerArray, null, isEncoded ? encodingStyle : null); serializer.Serialize(writer, headerArray, null); foreach (SoapHeader header in otherHeaders) { if (header is SoapUnknownHeader) { SoapUnknownHeader unknown = (SoapUnknownHeader)header; if (unknown.Element != null) { unknown.Element.WriteTo(writer); } } else if (!isEncoded) // encoded headers already appended to members mapping { string ns = SoapReflector.GetLiteralNamespace(defaultNs, serviceDefaultIsEncoded); new XmlSerializer(header.GetType(), ns).Serialize(writer, header); } } // reset the soap version for (int i = 0; i < headers.Count; i++) { SoapHeader header = headers[i]; if (header != null) { header.version = SoapProtocolVersion.Default; } } writer.WriteEndElement(); writer.Flush(); if (isEncoded && writer is XmlSpecialTextWriter) { ((XmlSpecialTextWriter)writer).EncodeIds = false; } }
private static string GetHeaderElementName(Type headerType) { return(SoapReflector.CreateXmlImporter(null, false).ImportTypeMapping(headerType).XsdElementName); }
internal override void WriteReturns(object[] returnValues, Stream outputStream) { if (serverMethod.oneWay) { return; } bool isEncoded = serverMethod.use == SoapBindingUse.Encoded; SoapHeaderHandling.EnsureHeadersUnderstood(message.Headers); message.Headers.Clear(); SoapHeaderHandling.GetHeaderMembers(message.Headers, this.Target, serverMethod.outHeaderMappings, SoapHeaderDirection.Out, false); if (message.allExtensions != null) { message.SetExtensionStream(new SoapExtensionStream()); } message.InitExtensionStreamChain(message.allExtensions); message.SetStage(SoapMessageStage.BeforeSerialize); message.ContentType = ContentType.Compose(helper.HttpContentType, Encoding.UTF8); message.SetParameterValues(returnValues); message.RunExtensions(message.allExtensions); message.SetStream(outputStream); Response.ContentType = message.ContentType; if (message.ContentEncoding != null && message.ContentEncoding.Length > 0) { Response.AppendHeader(ContentType.ContentEncoding, message.ContentEncoding); } StreamWriter sw = new StreamWriter(message.Stream, new UTF8Encoding(false), 128); XmlTextWriter writer = isEncoded && message.Headers.Count > 0 ? new XmlSpecialTextWriter(sw, helper.Version) : new XmlTextWriter(sw); writer.WriteStartDocument(); writer.WriteStartElement("soap", Soap.Envelope, helper.EnvelopeNs); writer.WriteAttributeString("xmlns", "soap", null, helper.EnvelopeNs); if (isEncoded) { writer.WriteAttributeString("xmlns", "soapenc", null, helper.EncodingNs); writer.WriteAttributeString("xmlns", "tns", null, serverType.serviceNamespace); writer.WriteAttributeString("xmlns", "types", null, SoapReflector.GetEncodedNamespace(serverType.serviceNamespace, serverType.serviceDefaultIsEncoded)); } if (serverMethod.rpc && version == SoapProtocolVersion.Soap12) { writer.WriteAttributeString("xmlns", "rpc", null, Soap12.RpcNamespace); } writer.WriteAttributeString("xmlns", "xsi", null, XmlSchema.InstanceNamespace); writer.WriteAttributeString("xmlns", "xsd", null, XmlSchema.Namespace); SoapHeaderHandling.WriteHeaders(writer, serverMethod.outHeaderSerializer, message.Headers, serverMethod.outHeaderMappings, SoapHeaderDirection.Out, isEncoded, serverType.serviceNamespace, serverType.serviceDefaultIsEncoded, helper.EnvelopeNs); writer.WriteStartElement(Soap.Body, helper.EnvelopeNs); if (isEncoded) { writer.WriteAttributeString("soap", Soap.EncodingStyle, null, helper.EncodingNs); } // SOAP12: not using encodingStyle //serverMethod.returnSerializer.Serialize(writer, returnValues, null, isEncoded ? helper.EncodingNs : null); serverMethod.returnSerializer.Serialize(writer, returnValues, null); writer.WriteEndElement(); writer.WriteEndElement(); writer.Flush(); message.SetStage(SoapMessageStage.AfterSerialize); message.RunExtensions(message.allExtensions); }
internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos) { if (methodInfos.Length == 0) { return(new object[0]); } WebServiceAttribute attribute = WebServiceReflector.GetAttribute(methodInfos); bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos)); XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(attribute.Namespace, serviceDefaultIsEncoded); WebMethodReflector.IncludeTypes(methodInfos, importer); ArrayList list = new ArrayList(); bool[] flagArray = new bool[methodInfos.Length]; for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; Type returnType = methodInfo.ReturnType; if (IsSupported(returnType) && HttpServerProtocol.AreUrlParametersSupported(methodInfo)) { XmlAttributes attributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); XmlTypeMapping mapping = importer.ImportTypeMapping(returnType, attributes.XmlRoot); mapping.SetKey(methodInfo.GetKey() + ":Return"); list.Add(mapping); flagArray[i] = true; } } if (list.Count == 0) { return(new object[0]); } XmlMapping[] mappings = (XmlMapping[])list.ToArray(typeof(XmlMapping)); Evidence evidenceForType = GetEvidenceForType(methodInfos[0].DeclaringType); TraceMethod caller = Tracing.On ? new TraceMethod(typeof(XmlReturn), "GetInitializers", methodInfos) : null; if (Tracing.On) { Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappings, evidenceForType })); } XmlSerializer[] serializerArray = null; if (AppDomain.CurrentDomain.IsHomogenous) { serializerArray = XmlSerializer.FromMappings(mappings); } else { serializerArray = XmlSerializer.FromMappings(mappings, evidenceForType); } if (Tracing.On) { Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller); } object[] objArray = new object[methodInfos.Length]; int num2 = 0; for (int j = 0; j < objArray.Length; j++) { if (flagArray[j]) { objArray[j] = serializerArray[num2++]; } } return(objArray); }