internal static void IncludeTypes(LogicalMethodInfo[] methods, SoapReflectionImporter importer) { for (int i = 0; i < methods.Length; i++) { LogicalMethodInfo method = methods[i]; IncludeTypes(method, importer); } }
internal static void IncludeTypes(LogicalMethodInfo[] methods, SoapReflectionImporter importer) { for (int i = 0; i < methods.Length; i++) { LogicalMethodInfo method = methods[i]; importer.IncludeTypes(method.DeclaringType); importer.IncludeTypes(method.CustomAttributeProvider); } }
XmlTypeMapping GetEncodedTypeMapping() { SoapReflectionImporter sri = new SoapReflectionImporter(); sri.IncludeType(typeof(UknTestPart)); sri.IncludeType(typeof(AnotherTestPart)); sri.IncludeType(typeof(DblStringContainer)); return(sri.ImportTypeMapping(typeof(Test))); }
public SoapTypeStubInfo(LogicalTypeInfo logicalTypeInfo) : base(logicalTypeInfo) { xmlImporter = new XmlReflectionImporter(); soapImporter = new SoapReflectionImporter(); if (typeof(SoapHttpClientProtocol).IsAssignableFrom(Type)) { if (Bindings.Count == 0 || ((BindingInfo)Bindings[0]).WebServiceBindingAttribute == null) { throw new InvalidOperationException("WebServiceBindingAttribute is required on proxy class '" + Type + "'."); } if (Bindings.Count > 1) { throw new InvalidOperationException("Only one WebServiceBinding attribute may be specified on type '" + Type + "'."); } } object [] o = Type.GetCustomAttributes(typeof(SoapDocumentServiceAttribute), false); if (o.Length == 1) { SoapDocumentServiceAttribute a = (SoapDocumentServiceAttribute)o [0]; ParameterStyle = a.ParameterStyle; SoapBindingStyle = SoapBindingStyle.Document; } else { o = Type.GetCustomAttributes(typeof(SoapRpcServiceAttribute), false); if (o.Length == 1) { SoapRpcServiceAttribute srs = (SoapRpcServiceAttribute)o [0]; ParameterStyle = SoapParameterStyle.Wrapped; SoapBindingStyle = SoapBindingStyle.Rpc; } else { ParameterStyle = SoapParameterStyle.Wrapped; SoapBindingStyle = SoapBindingStyle.Document; } } if (ParameterStyle == SoapParameterStyle.Default) { ParameterStyle = SoapParameterStyle.Wrapped; } xmlImporter.IncludeTypes(Type); soapImporter.IncludeTypes(Type); #if MONOTOUCH SoapExtensions = new SoapExtensionRuntimeConfig [2][]; #else SoapExtensions = SoapExtension.GetTypeExtensions(Type); #endif }
internal static void IncludeTypes(LogicalMethodInfo method, SoapReflectionImporter importer) { if (method.Declaration != null) { importer.IncludeTypes(method.Declaration.DeclaringType); importer.IncludeTypes(method.Declaration); } importer.IncludeTypes(method.DeclaringType); importer.IncludeTypes(method.CustomAttributeProvider); }
public static object SoapXmlDeserialize(string value, Type type) { var xmlTypeMapping = new SoapReflectionImporter().ImportTypeMapping(type); var xmlSerializer = new XmlSerializer(xmlTypeMapping); var xmlDocument = new XmlDocument(); xmlDocument.LoadXml(value); var xmlTextReader = new XmlTextReader(new StringReader(xmlDocument.OuterXml)); xmlTextReader.ReadStartElement(type.FullName); return(xmlSerializer.Deserialize(xmlTextReader)); }
private T DeSerialize <T>(string xml) { XmlTypeMapping myTypeMapping = new SoapReflectionImporter().ImportTypeMapping(typeof(T)); XmlSerializer serializer = new XmlSerializer(myTypeMapping); T serialized; using (var stringreader = new StringReader(xml)) { serialized = (T)serializer.Deserialize(stringreader); } return(serialized); }
static EchoRpcEncWithHeadersService() { var member = new XmlReflectionMember { MemberName = "StringHeader", MemberType = typeof(StringHeader), SoapAttributes = new SoapAttributes { SoapElement = new SoapElementAttribute("StringHeader") } }; var members = new XmlReflectionMember[] { member }; var mappings = new SoapReflectionImporter().ImportMembersMapping("EchoServiceSoap", "http://tempuri.org/", members, false, false); var serializers = XmlSerializer.FromMappings(new XmlMembersMapping[] { mappings }, typeof(EchoRpcEncWithHeadersService)); s_stringHeaderSerializer = serializers[0]; }
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 T FromXml <T>(string message) { T o; using (MemoryStream stream = new MemoryStream()) { SoapReflectionImporter soap = new SoapReflectionImporter(); var mapping = soap.ImportTypeMapping(typeof(T)); XmlSerializer s = new XmlSerializer(mapping); stream.Position = 0; var xmlReader = new XmlTextReader(stream); o = (T)s.Deserialize(xmlReader, message); xmlReader.Close(); } return(o); }
private String Serialize <T>(T request) { XmlTypeMapping myTypeMapping = new SoapReflectionImporter().ImportTypeMapping(typeof(T)); XmlSerializer serializer = new XmlSerializer((myTypeMapping)); string xml; var encoding = new UTF8Encoding(); var stream = new MemoryStream(); using (var writer = new XmlTextWriter(stream, encoding)) { serializer.Serialize(writer, request); stream = (MemoryStream)writer.BaseStream; xml = encoding.GetString(stream.ToArray()); } return(xml); }
private void SerializeOverride(string fileName) { SoapAttributeOverrides soapOver = new SoapAttributeOverrides(); SoapAttributes SoapAtts = new SoapAttributes(); // Add a SoapEnumAttribute for the GroupType.A enumerator. // Instead of 'A' it will be "West". SoapEnumAttribute soapEnum = new SoapEnumAttribute("West"); // Override the "A" enumerator. SoapAtts.SoapEnum = soapEnum; soapOver.Add(typeof(GroupType), "A", SoapAtts); // Add another SoapEnumAttribute for the GroupType.B enumerator. // Instead of //B// it will be "East". SoapAtts = new SoapAttributes(); soapEnum = new SoapEnumAttribute(); soapEnum.Name = "East"; SoapAtts.SoapEnum = soapEnum; soapOver.Add(typeof(GroupType), "B", SoapAtts); // Create an XmlSerializer used for overriding. XmlTypeMapping map = new SoapReflectionImporter(soapOver). ImportTypeMapping(typeof(Group)); XmlSerializer ser = new XmlSerializer(map); Group myGroup = new Group(); myGroup.GroupName = ".NET"; myGroup.Grouptype = GroupType.B; // Writing the file requires a TextWriter. TextWriter writer = new StreamWriter(fileName); ser.Serialize(writer, myGroup); writer.Close(); }
static XmlMembersMapping ImportMembersMapping(XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, bool serviceDefaultIsEncoded, bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, string elementName, string elementNamespace, bool nsIsDefault, XmlReflectionMember[] members, bool validate) { if (use == SoapBindingUse.Encoded) { string ns = (!rpc && paramStyle != SoapParameterStyle.Bare && nsIsDefault) ? GetEncodedNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace; return(soapImporter.ImportMembersMapping(elementName, ns, members, rpc || paramStyle != SoapParameterStyle.Bare, rpc, validate)); } else { string ns = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace; return(xmlImporter.ImportMembersMapping(elementName, ns, members, paramStyle != SoapParameterStyle.Bare)); } }
private XmlTypeMapping getQualifiedNameForSystemType(Type systemType) { SoapReflectionImporter sri = new SoapReflectionImporter(); return(sri.ImportTypeMapping(systemType)); }
// // Constructor // public SoapMethodStubInfo(TypeStubInfo typeStub, LogicalMethodInfo source, object kind, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter) : base(typeStub, source) { SoapTypeStubInfo parent = (SoapTypeStubInfo)typeStub; XmlElementAttribute optional_ns = null; if (kind == null) { Use = parent.LogicalType.BindingUse; RequestName = ""; RequestNamespace = ""; ResponseName = ""; ResponseNamespace = ""; ParameterStyle = parent.ParameterStyle; SoapBindingStyle = parent.SoapBindingStyle; OneWay = false; // disabled (see bug #332150) //#if NET_2_0 // if (parent.Type != source.DeclaringType) // Binding = source.DeclaringType.Name + parent.ProtocolName; //#endif } else if (kind is SoapDocumentMethodAttribute) { SoapDocumentMethodAttribute dma = (SoapDocumentMethodAttribute)kind; Use = dma.Use; if (Use == SoapBindingUse.Default) { if (parent.SoapBindingStyle == SoapBindingStyle.Document) { Use = parent.LogicalType.BindingUse; } else { Use = SoapBindingUse.Literal; } } Action = dma.Action; Binding = dma.Binding; RequestName = dma.RequestElementName; RequestNamespace = dma.RequestNamespace; ResponseName = dma.ResponseElementName; ResponseNamespace = dma.ResponseNamespace; ParameterStyle = dma.ParameterStyle; if (ParameterStyle == SoapParameterStyle.Default) { ParameterStyle = parent.ParameterStyle; } OneWay = dma.OneWay; SoapBindingStyle = SoapBindingStyle.Document; } else { SoapRpcMethodAttribute rma = (SoapRpcMethodAttribute)kind; Use = SoapBindingUse.Encoded; // RPC always use encoded Action = rma.Action; if (Action != null && Action.Length == 0) { Action = null; } Binding = rma.Binding; // When using RPC, MS.NET seems to ignore RequestElementName and // MessageName, and it always uses the method name RequestName = source.Name; ResponseName = source.Name + "Response"; // RequestName = rma.RequestElementName; // ResponseName = rma.ResponseElementName; RequestNamespace = rma.RequestNamespace; ResponseNamespace = rma.ResponseNamespace; ParameterStyle = SoapParameterStyle.Wrapped; OneWay = rma.OneWay; SoapBindingStyle = SoapBindingStyle.Rpc; // For RPC calls, make all arguments be part of the empty namespace optional_ns = new XmlElementAttribute(); optional_ns.Namespace = ""; } if (OneWay) { if (source.ReturnType != typeof(void)) { throw new Exception("OneWay methods should not have a return value."); } if (source.OutParameters.Length != 0) { throw new Exception("OneWay methods should not have out/ref parameters."); } } BindingInfo binfo = parent.GetBinding(Binding); if (binfo == null) { throw new InvalidOperationException("Type '" + parent.Type + "' is missing WebServiceBinding attribute that defines a binding named '" + Binding + "'."); } string serviceNamespace = binfo.Namespace; if (RequestNamespace == "") { RequestNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use); } if (ResponseNamespace == "") { ResponseNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use); } if (RequestName == "") { RequestName = Name; } if (ResponseName == "") { ResponseName = Name + "Response"; } if (Action == null) { Action = serviceNamespace.EndsWith("/") ? (serviceNamespace + Name) : (serviceNamespace + "/" + Name); } bool hasWrappingElem = (ParameterStyle == SoapParameterStyle.Wrapped); bool writeAccessors = (SoapBindingStyle == SoapBindingStyle.Rpc); XmlReflectionMember [] in_members = BuildRequestReflectionMembers(optional_ns); XmlReflectionMember [] out_members = BuildResponseReflectionMembers(optional_ns); if (Use == SoapBindingUse.Literal) { xmlImporter.IncludeTypes(source.CustomAttributeProvider); InputMembersMapping = xmlImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem); OutputMembersMapping = xmlImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem); } else { soapImporter.IncludeTypes(source.CustomAttributeProvider); InputMembersMapping = soapImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem, writeAccessors); OutputMembersMapping = soapImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem, writeAccessors); } requestSerializerId = parent.RegisterSerializer(InputMembersMapping); responseSerializerId = parent.RegisterSerializer(OutputMembersMapping); object[] o = source.GetCustomAttributes(typeof(SoapHeaderAttribute)); ArrayList allHeaderList = new ArrayList(o.Length); ArrayList inHeaderList = new ArrayList(o.Length); ArrayList outHeaderList = new ArrayList(o.Length); ArrayList faultHeaderList = new ArrayList(); SoapHeaderDirection unknownHeaderDirections = (SoapHeaderDirection)0; for (int i = 0; i < o.Length; i++) { SoapHeaderAttribute att = (SoapHeaderAttribute)o[i]; MemberInfo[] mems = source.DeclaringType.GetMember(att.MemberName); if (mems.Length == 0) { throw new InvalidOperationException("Member " + att.MemberName + " not found in class " + source.DeclaringType.FullName + "."); } HeaderInfo header = new HeaderInfo(mems[0], att); allHeaderList.Add(header); if (!header.Custom) { if ((header.Direction & SoapHeaderDirection.In) != 0) { inHeaderList.Add(header); } if ((header.Direction & SoapHeaderDirection.Out) != 0) { outHeaderList.Add(header); } if ((header.Direction & SoapHeaderDirection.Fault) != 0) { faultHeaderList.Add(header); } } else { unknownHeaderDirections |= header.Direction; } } Headers = (HeaderInfo[])allHeaderList.ToArray(typeof(HeaderInfo)); if (inHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.In) != 0) { InHeaders = (HeaderInfo[])inHeaderList.ToArray(typeof(HeaderInfo)); XmlReflectionMember[] members = BuildHeadersReflectionMembers(InHeaders); if (Use == SoapBindingUse.Literal) { InputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false); } else { InputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false); } requestHeadersSerializerId = parent.RegisterSerializer(InputHeaderMembersMapping); } if (outHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Out) != 0) { OutHeaders = (HeaderInfo[])outHeaderList.ToArray(typeof(HeaderInfo)); XmlReflectionMember[] members = BuildHeadersReflectionMembers(OutHeaders); if (Use == SoapBindingUse.Literal) { OutputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false); } else { OutputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false); } responseHeadersSerializerId = parent.RegisterSerializer(OutputHeaderMembersMapping); } if (faultHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Fault) != 0) { FaultHeaders = (HeaderInfo[])faultHeaderList.ToArray(typeof(HeaderInfo)); XmlReflectionMember[] members = BuildHeadersReflectionMembers(FaultHeaders); if (Use == SoapBindingUse.Literal) { FaultHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false); } else { FaultHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false); } faultHeadersSerializerId = parent.RegisterSerializer(FaultHeaderMembersMapping); } SoapExtensions = SoapExtension.GetMethodExtensions(source); }
public static string ObjectToXmlString_second(Object _object, Type objType) { // Create and return an XmlSerializer instance used to // override and create SOAP messages. SoapAttributeOverrides mySoapAttributeOverrides = new SoapAttributeOverrides(); SoapAttributes soapAtts = new SoapAttributes(); // Override the SoapTypeAttribute. SoapTypeAttribute soapType = new SoapTypeAttribute(); //soapType.TypeName = "Team"; soapType.IncludeInSchema = false; //soapType.Namespace = "http://www.microsoft.com"; // https://docs.microsoft.com/en-us/dotnet/api/system.xml.serialization.soaptypeattribute.includeinschema?view=netframework-4.8 // https://docs.microsoft.com/en-us/dotnet/standard/data/xml/ // https://stackoverflow.com/questions/1729711/prevent-xmlserializer-from-emitting-xsitype-on-inherited-types/1730412#1730412 // https://stackoverflow.com/questions/1729711/prevent-xmlserializer-from-emitting-xsitype-on-inherited-types/1730412 // https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/dkwy2d72(v=vs.100) // https://csharp.hotexamples.com/examples/System.Xml/XmlWriterSettings/-/php-xmlwritersettings-class-examples.html //mySoapAttributeOverrides.Add(typeof(QuoteData), soapAtts); mySoapAttributeOverrides.Add(objType, soapAtts); // Serializes a class named Group as a SOAP message. XmlTypeMapping myTypeMapping = new SoapReflectionImporter(mySoapAttributeOverrides).ImportTypeMapping(objType); XmlSerializer mySerializer = new XmlSerializer(myTypeMapping); //XmlSerializer mySerializer = new XmlSerializer(objType); XmlWriterSettings settings = new XmlWriterSettings(); // this removes <?xml version="1.0" encoding="utf-16"?> //settings.ConformanceLevel = ConformanceLevel.Document; //settings.ConformanceLevel = ConformanceLevel.Auto; settings.OmitXmlDeclaration = true; settings.Indent = false; // this removes <?xml version="1.0" encoding="utf-16"?> //settings.OmitXmlDeclaration = true; settings.NewLineChars = string.Empty; settings.NewLineHandling = NewLineHandling.None; string xmlStr = string.Empty; using (StringWriter stringWriter = new StringWriter()) { using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, settings)) { mySerializer.Serialize(xmlWriter, _object); xmlStr = stringWriter.ToString(); xmlWriter.Close(); } stringWriter.Close(); } return(xmlStr); }
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); } }
// SERIALIZE public override void OnActionExecuted(ActionExecutedContext filterContext) { // Can't do anything if the result hasn't been set as a ViewResult if (!(filterContext.Result is ViewResult)) { return; } // Don't change anything if an error code has been set try { if (filterContext.HttpContext.Response.StatusCode >= 300) { return; } } catch { } // SETUP UTF8Encoding utf8 = new UTF8Encoding(false); HttpRequestBase request = filterContext.RequestContext.HttpContext.Request; String contentType = request.ContentType ?? string.Empty; ViewResult view = (ViewResult)(filterContext.Result); var data = view.ViewData.Model; // Did caller request the XSD? if (request.QueryString.ToString().IndexOf("XSD", StringComparison.InvariantCultureIgnoreCase) != -1) { // Generate an XSD document from the class string finalXSD = string.Empty; var soapReflectionImporter = new SoapReflectionImporter(); var xmlTypeMapping = soapReflectionImporter.ImportTypeMapping(data.GetType()); var xmlSchemas = new XmlSchemas(); var xmlSchema = new XmlSchema(); xmlSchemas.Add(xmlSchema); var xmlSchemaExporter = new XmlSchemaExporter(xmlSchemas); xmlSchemaExporter.ExportTypeMapping(xmlTypeMapping); MemoryStream ms = new MemoryStream(); xmlSchema.Write(ms); ms.Position = 0; ms.Capacity = Convert.ToInt32(ms.Length); XmlDocument xmldoc = new XmlDocument(); xmldoc.Load(ms); finalXSD = xmldoc.InnerXml; ms.Close(); ms.Dispose(); filterContext.Result = new ContentResult { ContentType = "text/xml", Content = finalXSD, ContentEncoding = System.Text.Encoding.UTF8 }; } // Did caller request XML result? else if (request.QueryString.ToString().IndexOf("XML", StringComparison.InvariantCultureIgnoreCase) != -1) { string objectAsXml = SerializeObjectAsXML(data, null); filterContext.Result = new ContentResult { ContentType = "text/xml", Content = objectAsXml, ContentEncoding = System.Text.Encoding.UTF8 }; } // Did caller request JSON result? else if (request.QueryString.ToString().IndexOf("JSON", StringComparison.InvariantCultureIgnoreCase) != -1) { using (var stream = new MemoryStream()) { JavaScriptSerializer js = new JavaScriptSerializer(); String content = js.Serialize(data); filterContext.Result = new ContentResult { ContentType = "application/json", Content = content, ContentEncoding = System.Text.Encoding.UTF8 }; } } // Did caller request HTML result? else if (request.QueryString.ToString().IndexOf("HTML", StringComparison.InvariantCultureIgnoreCase) != -1) { filterContext.Result = filterContext.Result; // Nothing to modify here } // Not specified, so we will default response to XML else { string objectAsXml = SerializeObjectAsXML(data, null); filterContext.Result = new ContentResult { ContentType = "text/xml", Content = objectAsXml, ContentEncoding = System.Text.Encoding.UTF8 }; } }
internal XmlSerializerImporter(string defaultNs) { this.defaultNs = defaultNs; this.xmlImporter = null; this.soapImporter = null; }
internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs) { SoapReflectedMethod method2; try { string str2; string str4; string key = methodInfo.GetKey(); SoapReflectedMethod method = new SoapReflectedMethod(); MethodAttribute attribute = new MethodAttribute(); object soapServiceAttribute = GetSoapServiceAttribute(methodInfo.DeclaringType); bool serviceDefaultIsEncoded = ServiceDefaultIsEncoded(soapServiceAttribute); object soapMethodAttribute = GetSoapMethodAttribute(methodInfo); if (soapMethodAttribute == null) { if (client) { return(null); } if (soapServiceAttribute is SoapRpcServiceAttribute) { SoapRpcMethodAttribute attribute2 = new SoapRpcMethodAttribute { Use = ((SoapRpcServiceAttribute)soapServiceAttribute).Use }; soapMethodAttribute = attribute2; } else if (soapServiceAttribute is SoapDocumentServiceAttribute) { SoapDocumentMethodAttribute attribute3 = new SoapDocumentMethodAttribute { Use = ((SoapDocumentServiceAttribute)soapServiceAttribute).Use }; soapMethodAttribute = attribute3; } else { soapMethodAttribute = new SoapDocumentMethodAttribute(); } } if (soapMethodAttribute is SoapRpcMethodAttribute) { SoapRpcMethodAttribute attribute4 = (SoapRpcMethodAttribute)soapMethodAttribute; method.rpc = true; method.use = attribute4.Use; method.oneWay = attribute4.OneWay; attribute.action = attribute4.Action; attribute.binding = attribute4.Binding; attribute.requestName = attribute4.RequestElementName; attribute.requestNs = attribute4.RequestNamespace; attribute.responseName = attribute4.ResponseElementName; attribute.responseNs = attribute4.ResponseNamespace; } else { SoapDocumentMethodAttribute attribute5 = (SoapDocumentMethodAttribute)soapMethodAttribute; method.rpc = false; method.use = attribute5.Use; method.paramStyle = attribute5.ParameterStyle; method.oneWay = attribute5.OneWay; attribute.action = attribute5.Action; attribute.binding = attribute5.Binding; attribute.requestName = attribute5.RequestElementName; attribute.requestNs = attribute5.RequestNamespace; attribute.responseName = attribute5.ResponseElementName; attribute.responseNs = attribute5.ResponseNamespace; if (method.use == SoapBindingUse.Default) { if (soapServiceAttribute is SoapDocumentServiceAttribute) { method.use = ((SoapDocumentServiceAttribute)soapServiceAttribute).Use; } if (method.use == SoapBindingUse.Default) { method.use = SoapBindingUse.Literal; } } if (method.paramStyle == SoapParameterStyle.Default) { if (soapServiceAttribute is SoapDocumentServiceAttribute) { method.paramStyle = ((SoapDocumentServiceAttribute)soapServiceAttribute).ParameterStyle; } if (method.paramStyle == SoapParameterStyle.Default) { method.paramStyle = SoapParameterStyle.Wrapped; } } } if (attribute.binding.Length > 0) { if (client) { throw new InvalidOperationException(System.Web.Services.Res.GetString("WebInvalidBindingPlacement", new object[] { soapMethodAttribute.GetType().Name })); } method.binding = WebServiceBindingReflector.GetAttribute(methodInfo, attribute.binding); } WebMethodAttribute methodAttribute = methodInfo.MethodAttribute; method.name = methodAttribute.MessageName; if (method.name.Length == 0) { method.name = methodInfo.Name; } if (method.rpc) { str2 = ((attribute.requestName.Length == 0) || !client) ? methodInfo.Name : attribute.requestName; } else { str2 = (attribute.requestName.Length == 0) ? method.name : attribute.requestName; } string requestNs = attribute.requestNs; if (requestNs == null) { if (((method.binding != null) && (method.binding.Namespace != null)) && (method.binding.Namespace.Length != 0)) { requestNs = method.binding.Namespace; } else { requestNs = defaultNs; } } if (method.rpc && (method.use != SoapBindingUse.Encoded)) { str4 = methodInfo.Name + "Response"; } else { str4 = (attribute.responseName.Length == 0) ? (method.name + "Response") : attribute.responseName; } string responseNs = attribute.responseNs; if (responseNs == null) { if (((method.binding != null) && (method.binding.Namespace != null)) && (method.binding.Namespace.Length != 0)) { responseNs = method.binding.Namespace; } else { responseNs = defaultNs; } } SoapParameterInfo[] infoArray = ReflectParameters(methodInfo.InParameters, requestNs); SoapParameterInfo[] infoArray2 = ReflectParameters(methodInfo.OutParameters, responseNs); method.action = attribute.action; if (method.action == null) { method.action = GetDefaultAction(defaultNs, methodInfo); } method.methodInfo = methodInfo; if (method.oneWay) { if (infoArray2.Length > 0) { throw new ArgumentException(System.Web.Services.Res.GetString("WebOneWayOutParameters"), "methodInfo"); } if (methodInfo.ReturnType != typeof(void)) { throw new ArgumentException(System.Web.Services.Res.GetString("WebOneWayReturnValue"), "methodInfo"); } } XmlReflectionMember[] members = new XmlReflectionMember[infoArray.Length]; for (int i = 0; i < members.Length; i++) { SoapParameterInfo info = infoArray[i]; XmlReflectionMember member = new XmlReflectionMember { MemberName = info.parameterInfo.Name, MemberType = info.parameterInfo.ParameterType }; if (member.MemberType.IsByRef) { member.MemberType = member.MemberType.GetElementType(); } member.XmlAttributes = info.xmlAttributes; member.SoapAttributes = info.soapAttributes; members[i] = member; } method.requestMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, method.rpc, method.use, method.paramStyle, str2, requestNs, attribute.requestNs == null, members, true, false, key, client); if (((GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.RequestElement) && (method.paramStyle == SoapParameterStyle.Bare)) && (method.requestMappings.Count != 1)) { throw new ArgumentException(System.Web.Services.Res.GetString("WhenUsingAMessageStyleOfParametersAsDocument0"), "methodInfo"); } string name = ""; string ns = ""; if (method.paramStyle == SoapParameterStyle.Bare) { if (method.requestMappings.Count == 1) { name = method.requestMappings[0].XsdElementName; ns = method.requestMappings[0].Namespace; } } else { name = method.requestMappings.XsdElementName; ns = method.requestMappings.Namespace; } method.requestElementName = new XmlQualifiedName(name, ns); if (!method.oneWay) { int num2 = infoArray2.Length; int num3 = 0; CodeIdentifiers identifiers = null; if (methodInfo.ReturnType != typeof(void)) { num2++; num3 = 1; identifiers = new CodeIdentifiers(); } members = new XmlReflectionMember[num2]; for (int m = 0; m < infoArray2.Length; m++) { SoapParameterInfo info2 = infoArray2[m]; XmlReflectionMember member2 = new XmlReflectionMember { MemberName = info2.parameterInfo.Name, MemberType = info2.parameterInfo.ParameterType }; if (member2.MemberType.IsByRef) { member2.MemberType = member2.MemberType.GetElementType(); } member2.XmlAttributes = info2.xmlAttributes; member2.SoapAttributes = info2.soapAttributes; members[num3++] = member2; if (identifiers != null) { identifiers.Add(member2.MemberName, null); } } if (methodInfo.ReturnType != typeof(void)) { XmlReflectionMember member3 = new XmlReflectionMember { MemberName = identifiers.MakeUnique(method.name + "Result"), MemberType = methodInfo.ReturnType, IsReturnValue = true, XmlAttributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider) }; member3.XmlAttributes.XmlRoot = null; member3.SoapAttributes = new SoapAttributes(methodInfo.ReturnTypeCustomAttributeProvider); members[0] = member3; } method.responseMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, method.rpc, method.use, method.paramStyle, str4, responseNs, attribute.responseNs == null, members, false, false, key + ":Response", !client); } SoapExtensionAttribute[] customAttributes = (SoapExtensionAttribute[])methodInfo.GetCustomAttributes(typeof(SoapExtensionAttribute)); method.extensions = new SoapReflectedExtension[customAttributes.Length]; for (int j = 0; j < customAttributes.Length; j++) { method.extensions[j] = new SoapReflectedExtension(customAttributes[j].ExtensionType, customAttributes[j]); } Array.Sort <SoapReflectedExtension>(method.extensions); SoapHeaderAttribute[] array = (SoapHeaderAttribute[])methodInfo.GetCustomAttributes(typeof(SoapHeaderAttribute)); Array.Sort(array, new SoapHeaderAttributeComparer()); Hashtable hashtable = new Hashtable(); method.headers = new SoapReflectedHeader[array.Length]; int num6 = 0; int length = method.headers.Length; ArrayList list = new ArrayList(); ArrayList list2 = new ArrayList(); for (int k = 0; k < method.headers.Length; k++) { SoapHeaderAttribute attribute7 = array[k]; SoapReflectedHeader header = new SoapReflectedHeader(); Type declaringType = methodInfo.DeclaringType; header.memberInfo = declaringType.GetField(attribute7.MemberName); if (header.memberInfo != null) { header.headerType = ((FieldInfo)header.memberInfo).FieldType; } else { header.memberInfo = declaringType.GetProperty(attribute7.MemberName); if (header.memberInfo == null) { throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderMissing"); } header.headerType = ((PropertyInfo)header.memberInfo).PropertyType; } if (header.headerType.IsArray) { header.headerType = header.headerType.GetElementType(); header.repeats = true; if ((header.headerType != typeof(SoapUnknownHeader)) && (header.headerType != typeof(SoapHeader))) { throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderType"); } } if (MemberHelper.IsStatic(header.memberInfo)) { throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderStatic"); } if (!MemberHelper.CanRead(header.memberInfo)) { throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderRead"); } if (!MemberHelper.CanWrite(header.memberInfo)) { throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderWrite"); } if (!typeof(SoapHeader).IsAssignableFrom(header.headerType)) { throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderType"); } SoapHeaderDirection direction = attribute7.Direction; if (method.oneWay && ((direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0)) { throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderOneWayOut"); } if (hashtable.Contains(header.headerType)) { SoapHeaderDirection direction2 = (SoapHeaderDirection)hashtable[header.headerType]; if ((direction2 & direction) != 0) { throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebMultiplyDeclaredHeaderTypes"); } hashtable[header.headerType] = direction | direction2; } else { hashtable[header.headerType] = direction; } if ((header.headerType != typeof(SoapHeader)) && (header.headerType != typeof(SoapUnknownHeader))) { XmlReflectionMember member4 = new XmlReflectionMember { MemberName = header.headerType.Name, MemberType = header.headerType }; XmlAttributes attributes = new XmlAttributes(header.headerType); if (attributes.XmlRoot != null) { member4.XmlAttributes = new XmlAttributes(); XmlElementAttribute attribute8 = new XmlElementAttribute { ElementName = attributes.XmlRoot.ElementName, Namespace = attributes.XmlRoot.Namespace }; member4.XmlAttributes.XmlElements.Add(attribute8); } member4.OverrideIsNullable = true; if ((direction & SoapHeaderDirection.In) != 0) { list.Add(member4); } if ((direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0) { list2.Add(member4); } header.custom = true; } header.direction = direction; if (!header.custom) { method.headers[--length] = header; } else { method.headers[num6++] = header; } } method.inHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, method.use, SoapParameterStyle.Bare, str2 + "InHeaders", defaultNs, true, (XmlReflectionMember[])list.ToArray(typeof(XmlReflectionMember)), false, true, key + ":InHeaders", client); if (!method.oneWay) { method.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, method.use, SoapParameterStyle.Bare, str4 + "OutHeaders", defaultNs, true, (XmlReflectionMember[])list2.ToArray(typeof(XmlReflectionMember)), false, true, key + ":OutHeaders", !client); } method2 = method; } catch (Exception exception) { if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException)) { throw; } throw new InvalidOperationException(System.Web.Services.Res.GetString("WebReflectionErrorMethod", new object[] { methodInfo.DeclaringType.Name, methodInfo.Name }), exception); } return(method2); }
private void OnWriteXmlSerializerBodyContents(XmlDictionaryWriter writer) { Debug.Assert(_outResults != null, "Object should set empty out results"); // Do not wrap old-style single element response into additional xml element for xml serializer var needResponseEnvelope = _result == null || (_outResults.Count > 0) || !_operation.IsMessageContractResponse; if (needResponseEnvelope) { writer.WriteStartElement(_envelopeName, _serviceNamespace); } foreach (var outResult in _outResults) { string value = null; if (outResult.Value is Guid) { value = outResult.Value.ToString(); } else if (outResult.Value is bool) { value = outResult.Value.ToString().ToLower(); } else if (outResult.Value is string) { value = System.Security.SecurityElement.Escape(outResult.Value.ToString()); } else if (outResult.Value is Enum) { value = outResult.Value.ToString(); } else if (outResult.Value == null) { value = null; } else { //for complex types using (var ms = new MemoryStream()) using (var stream = new BufferedStream(ms)) { // write element with name as outResult.Key and type information as outResultType // i.e. <outResult.Key xsi:type="outResultType" ... /> var outResultType = outResult.Value.GetType(); var serializer = CachedXmlSerializer.GetXmlSerializer(outResultType, outResult.Key, _serviceNamespace); lock (serializer) { serializer.Serialize(stream, outResult.Value); } //add outResultType. ugly, but working stream.Position = 0; XmlDocument xdoc = new XmlDocument(); xdoc.Load(stream); var attr = xdoc.CreateAttribute("xsi", "type", Namespaces.XMLNS_XSI); attr.Value = outResultType.Name; xdoc.DocumentElement.Attributes.Prepend(attr); writer.WriteRaw(xdoc.DocumentElement.OuterXml); } } if (value != null) { writer.WriteRaw(string.Format("<{0}>{1}</{0}>", outResult.Key, value)); } } if (_result != null) { // see https://referencesource.microsoft.com/System.Xml/System/Xml/Serialization/XmlSerializer.cs.html#c97688a6c07294d5 var resultType = _result.GetType(); var xmlRootAttr = resultType.GetTypeInfo().GetCustomAttributes <XmlRootAttribute>().FirstOrDefault(); var messageContractAttribute = resultType.GetTypeInfo().GetCustomAttribute <MessageContractAttribute>(); var xmlName = _operation.ReturnElementName ?? (needResponseEnvelope ? (string.IsNullOrWhiteSpace(xmlRootAttr?.ElementName) ? _resultName : xmlRootAttr.ElementName) : (string.IsNullOrWhiteSpace(xmlRootAttr?.ElementName) ? resultType.Name : xmlRootAttr.ElementName)); var xmlNs = _operation.ReturnNamespace ?? messageContractAttribute?.WrapperNamespace ?? (string.IsNullOrWhiteSpace(xmlRootAttr?.Namespace) ? _serviceNamespace : xmlRootAttr.Namespace); var xmlArrayAttr = _operation.DispatchMethod.GetCustomAttribute <XmlArrayAttribute>(); if (xmlArrayAttr != null && resultType.IsArray) { var serializer = CachedXmlSerializer.GetXmlSerializer(resultType.GetElementType(), xmlName, xmlNs); lock (serializer) { serializer.SerializeArray(writer, (object[])_result); } } else { // This behavior is opt-in i.e. you have to explicitly have a [MessageContract(IsWrapped=false)] // to have the message body members inlined. var shouldInline = (messageContractAttribute != null && messageContractAttribute.IsWrapped == false) || resultType.GetMembersWithAttribute <MessageHeaderAttribute>().Any(); if (shouldInline) { var memberInformation = resultType.GetMembersWithAttribute <MessageBodyMemberAttribute>().Select(mi => new { Member = mi, MessageBodyMemberAttribute = mi.GetCustomAttribute <MessageBodyMemberAttribute>() }).OrderBy(x => x.MessageBodyMemberAttribute?.Order ?? 0); if (messageContractAttribute != null && messageContractAttribute.IsWrapped) { writer.WriteStartElement(resultType.Name, xmlNs); } foreach (var memberInfo in memberInformation) { var memberType = memberInfo.Member.GetPropertyOrFieldType(); var memberValue = memberInfo.Member.GetPropertyOrFieldValue(_result); var memberName = memberInfo.MessageBodyMemberAttribute?.Name ?? memberInfo.Member.Name; var memberNamespace = memberInfo.MessageBodyMemberAttribute?.Namespace ?? _serviceNamespace; var serializer = CachedXmlSerializer.GetXmlSerializer(memberType, memberName, memberNamespace); lock (serializer) { if (memberValue is Stream) { writer.WriteStartElement(memberName, _serviceNamespace); WriteStream(writer, memberValue); writer.WriteEndElement(); } else { serializer.Serialize(writer, memberValue); } } } if (messageContractAttribute != null && messageContractAttribute.IsWrapped) { writer.WriteEndElement(); } } else { var serializer = CachedXmlSerializer.GetXmlSerializer(resultType, xmlName, xmlNs); lock (serializer) { if (_result is Stream) { writer.WriteStartElement(_resultName, _serviceNamespace); WriteStream(writer, _result); writer.WriteEndElement(); } else { //https://github.com/DigDes/SoapCore/issues/385 if (_operation.DispatchMethod.GetCustomAttribute <XmlSerializerFormatAttribute>()?.Style == OperationFormatStyle.Rpc) { var importer = new SoapReflectionImporter(_serviceNamespace); var typeMapping = importer.ImportTypeMapping(resultType); var accessor = typeMapping.GetType().GetProperty("Accessor", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(typeMapping); accessor?.GetType().GetProperty("Name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(accessor, xmlName); new XmlSerializer(typeMapping).Serialize(writer, _result); } serializer.Serialize(writer, _result); } } } } } if (needResponseEnvelope) { writer.WriteEndElement(); } }
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 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; } } }
internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs) { try { SoapReflectedMethod soapMethod = new SoapReflectedMethod(); MethodAttribute methodAttribute = new MethodAttribute(); object serviceAttr = GetSoapServiceAttribute(methodInfo.DeclaringType); bool serviceDefaultIsEncoded = ServiceDefaultIsEncoded(serviceAttr); object methodAttr = GetSoapMethodAttribute(methodInfo); if (methodAttr == null) { if (client) { return(null); // method attribute required on the client } if (serviceAttr is SoapRpcServiceAttribute) { methodAttr = new SoapRpcMethodAttribute(); } else { methodAttr = new SoapDocumentMethodAttribute(); } } if (methodAttr is SoapRpcMethodAttribute) { SoapRpcMethodAttribute attr = (SoapRpcMethodAttribute)methodAttr; soapMethod.rpc = true; soapMethod.use = SoapBindingUse.Encoded; soapMethod.oneWay = attr.OneWay; methodAttribute.action = attr.Action; methodAttribute.binding = attr.Binding; methodAttribute.requestName = attr.RequestElementName; methodAttribute.requestNs = attr.RequestNamespace; methodAttribute.responseName = attr.ResponseElementName; methodAttribute.responseNs = attr.ResponseNamespace; } else { SoapDocumentMethodAttribute attr = (SoapDocumentMethodAttribute)methodAttr; soapMethod.rpc = false; soapMethod.use = attr.Use; soapMethod.paramStyle = attr.ParameterStyle; soapMethod.oneWay = attr.OneWay; methodAttribute.action = attr.Action; methodAttribute.binding = attr.Binding; methodAttribute.requestName = attr.RequestElementName; methodAttribute.requestNs = attr.RequestNamespace; methodAttribute.responseName = attr.ResponseElementName; methodAttribute.responseNs = attr.ResponseNamespace; if (soapMethod.use == SoapBindingUse.Default) { if (serviceAttr is SoapDocumentServiceAttribute) { soapMethod.use = ((SoapDocumentServiceAttribute)serviceAttr).Use; } if (soapMethod.use == SoapBindingUse.Default) { soapMethod.use = SoapBindingUse.Literal; } } if (soapMethod.paramStyle == SoapParameterStyle.Default) { if (serviceAttr is SoapDocumentServiceAttribute) { soapMethod.paramStyle = ((SoapDocumentServiceAttribute)serviceAttr).ParameterStyle; } if (soapMethod.paramStyle == SoapParameterStyle.Default) { soapMethod.paramStyle = SoapParameterStyle.Wrapped; } } } if (methodAttribute.binding.Length > 0) { if (client) { throw new InvalidOperationException(Res.GetString(Res.WebInvalidBindingPlacement, methodAttr.GetType().Name)); } soapMethod.binding = WebServiceBindingReflector.GetAttribute(methodInfo, methodAttribute.binding); } WebMethodAttribute webMethodAttribute = WebMethodReflector.GetAttribute(methodInfo); soapMethod.name = webMethodAttribute.MessageName; if (soapMethod.name.Length == 0) { soapMethod.name = methodInfo.Name; } string requestElementName; if (soapMethod.rpc) { requestElementName = methodInfo.Name; } else { requestElementName = methodAttribute.requestName.Length == 0 ? soapMethod.name : methodAttribute.requestName; } string requestNamespace = methodAttribute.requestNs; if (requestNamespace == null) { if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0) { requestNamespace = soapMethod.binding.Namespace; } else { requestNamespace = defaultNs; } } string responseElementName = methodAttribute.responseName.Length == 0 ? soapMethod.name + "Response": methodAttribute.responseName; string responseNamespace = methodAttribute.responseNs; if (responseNamespace == null) { if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0) { responseNamespace = soapMethod.binding.Namespace; } else { responseNamespace = defaultNs; } } SoapParameterInfo[] inParameters = ReflectParameters(methodInfo.InParameters, requestNamespace); SoapParameterInfo[] outParameters = ReflectParameters(methodInfo.OutParameters, responseNamespace); soapMethod.action = methodAttribute.action; if (soapMethod.action == null) { soapMethod.action = GetDefaultAction(defaultNs, methodInfo); } soapMethod.methodInfo = methodInfo; if (soapMethod.oneWay) { if (outParameters.Length > 0) { throw new ArgumentException(Res.GetString(Res.WebOneWayOutParameters), "methodInfo"); } if (methodInfo.ReturnType != typeof(void)) { throw new ArgumentException(Res.GetString(Res.WebOneWayReturnValue), "methodInfo"); } } XmlReflectionMember[] members = new XmlReflectionMember[inParameters.Length]; for (int i = 0; i < members.Length; i++) { SoapParameterInfo soapParamInfo = inParameters[i]; XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = soapParamInfo.parameterInfo.Name; member.MemberType = soapParamInfo.parameterInfo.ParameterType; if (member.MemberType.IsByRef) { member.MemberType = member.MemberType.GetElementType(); } member.XmlAttributes = soapParamInfo.xmlAttributes; member.SoapAttributes = soapParamInfo.soapAttributes; members[i] = member; } soapMethod.requestMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, requestElementName, requestNamespace, methodAttribute.requestNs == null, members, true); if (GetSoapServiceRoutingStyle(serviceAttr) == SoapServiceRoutingStyle.RequestElement && soapMethod.paramStyle == SoapParameterStyle.Bare && soapMethod.requestMappings.Count != 1) { throw new ArgumentException(Res.GetString(Res.WhenUsingAMessageStyleOfParametersAsDocument0), "methodInfo"); } string elementName = ""; string elementNamespace = ""; if (soapMethod.paramStyle == SoapParameterStyle.Bare) { if (soapMethod.requestMappings.Count == 1) { elementName = soapMethod.requestMappings[0].ElementName; elementNamespace = soapMethod.requestMappings[0].Namespace; } // else: can't route on request element -- we match on an empty qname, // normal rules apply for duplicates } else { elementName = soapMethod.requestMappings.ElementName; elementNamespace = soapMethod.requestMappings.Namespace; } soapMethod.requestElementName = new XmlQualifiedName(elementName, elementNamespace); if (!soapMethod.oneWay) { int numOutParams = outParameters.Length; int count = 0; CodeIdentifiers identifiers = null; if (methodInfo.ReturnType != typeof(void)) { numOutParams++; count = 1; identifiers = new CodeIdentifiers(); } members = new XmlReflectionMember[numOutParams]; for (int i = 0; i < outParameters.Length; i++) { SoapParameterInfo soapParamInfo = outParameters[i]; XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = soapParamInfo.parameterInfo.Name; member.MemberType = soapParamInfo.parameterInfo.ParameterType; if (member.MemberType.IsByRef) { member.MemberType = member.MemberType.GetElementType(); } member.XmlAttributes = soapParamInfo.xmlAttributes; member.SoapAttributes = soapParamInfo.soapAttributes; members[count++] = member; if (identifiers != null) { identifiers.Add(member.MemberName, null); } } if (methodInfo.ReturnType != typeof(void)) { XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = identifiers.MakeUnique(soapMethod.name + "Result"); member.MemberType = methodInfo.ReturnType; member.IsReturnValue = true; member.XmlAttributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); member.XmlAttributes.XmlRoot = null; // Ignore XmlRoot attribute used by get/post member.SoapAttributes = new SoapAttributes(methodInfo.ReturnTypeCustomAttributeProvider); members[0] = member; } soapMethod.responseMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, responseElementName, responseNamespace, methodAttribute.responseNs == null, members, false); } SoapExtensionAttribute[] extensionAttributes = (SoapExtensionAttribute[])methodInfo.GetCustomAttributes(typeof(SoapExtensionAttribute)); soapMethod.extensions = new SoapReflectedExtension[extensionAttributes.Length]; for (int i = 0; i < extensionAttributes.Length; i++) { soapMethod.extensions[i] = new SoapReflectedExtension(extensionAttributes[i].ExtensionType, extensionAttributes[i]); } Array.Sort(soapMethod.extensions); SoapHeaderAttribute[] headerAttributes = (SoapHeaderAttribute[])methodInfo.GetCustomAttributes(typeof(SoapHeaderAttribute)); Array.Sort(headerAttributes, new SoapHeaderAttributeComparer()); Hashtable headerTypes = new Hashtable(); soapMethod.headers = new SoapReflectedHeader[headerAttributes.Length]; int front = 0; int back = soapMethod.headers.Length; ArrayList inHeaders = new ArrayList(); ArrayList outHeaders = new ArrayList(); for (int i = 0; i < soapMethod.headers.Length; i++) { SoapHeaderAttribute headerAttribute = headerAttributes[i]; SoapReflectedHeader soapHeader = new SoapReflectedHeader(); Type declaringType = methodInfo.DeclaringType; if ((soapHeader.memberInfo = declaringType.GetField(headerAttribute.MemberName)) != null) { soapHeader.headerType = ((FieldInfo)soapHeader.memberInfo).FieldType; } else if ((soapHeader.memberInfo = declaringType.GetProperty(headerAttribute.MemberName)) != null) { soapHeader.headerType = ((PropertyInfo)soapHeader.memberInfo).PropertyType; } else { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderMissing); } if (soapHeader.headerType.IsArray) { soapHeader.headerType = soapHeader.headerType.GetElementType(); soapHeader.repeats = true; if (soapHeader.headerType != typeof(SoapUnknownHeader) && soapHeader.headerType != typeof(SoapHeader)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType); } } if (MemberHelper.IsStatic(soapHeader.memberInfo)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderStatic); } if (!MemberHelper.CanRead(soapHeader.memberInfo)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderRead); } if (!MemberHelper.CanWrite(soapHeader.memberInfo)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderWrite); } if (!typeof(SoapHeader).IsAssignableFrom(soapHeader.headerType)) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType); } SoapHeaderDirection direction = headerAttribute.Direction; if (soapMethod.oneWay && (direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderOneWayOut); } if (headerTypes.Contains(soapHeader.headerType)) { SoapHeaderDirection prevDirection = (SoapHeaderDirection)headerTypes[soapHeader.headerType]; if ((prevDirection & direction) != 0) { throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebMultiplyDeclaredHeaderTypes); } headerTypes[soapHeader.headerType] = direction | prevDirection; } else { headerTypes[soapHeader.headerType] = direction; } if (soapHeader.headerType != typeof(SoapHeader) && soapHeader.headerType != typeof(SoapUnknownHeader)) { XmlReflectionMember member = new XmlReflectionMember(); member.MemberName = soapHeader.headerType.Name; member.MemberType = soapHeader.headerType; member.OverrideIsNullable = true; if ((direction & SoapHeaderDirection.In) != 0) { inHeaders.Add(member); } if ((direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0) { outHeaders.Add(member); } soapHeader.custom = true; } soapHeader.direction = direction; // Put generic header mappings at the end of the list so they are found last during header processing if (!soapHeader.custom) { soapMethod.headers[--back] = soapHeader; } else { soapMethod.headers[front++] = soapHeader; } } soapMethod.inHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, "InHeaders", defaultNs, true, (XmlReflectionMember[])inHeaders.ToArray(typeof(XmlReflectionMember)), false); if (!soapMethod.oneWay) { soapMethod.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, "OutHeaders", defaultNs, true, (XmlReflectionMember[])outHeaders.ToArray(typeof(XmlReflectionMember)), false); } return(soapMethod); } catch (Exception e) { throw new InvalidOperationException(Res.GetString(Res.WebReflectionErrorMethod, methodInfo.DeclaringType.Name, methodInfo.Name), e); } }
private object[] GetRequestArguments(Message requestMessage, System.Xml.XmlDictionaryReader xmlReader, OperationDescription operation, HttpContext httpContext) { var arguments = new object[operation.AllParameters.Length]; IEnumerable <Type> serviceKnownTypes = operation .GetServiceKnownTypesHierarchy() .Select(x => x.Type); // if any ordering issues, possible to rewrite like: /*while (!xmlReader.EOF) * { * var parameterInfo = operation.InParameters.FirstOrDefault(p => p.Name == xmlReader.LocalName && p.Namespace == xmlReader.NamespaceURI); * if (parameterInfo == null) * { * xmlReader.Skip(); * continue; * } * var parameterName = parameterInfo.Name; * var parameterNs = parameterInfo.Namespace; * ... * }*/ // Find the element for the operation's data if (!operation.IsMessageContractRequest) { xmlReader.ReadStartElement(operation.Name, operation.Contract.Namespace); foreach (var parameterInfo in operation.InParameters) { var parameterType = parameterInfo.Parameter.ParameterType; if (parameterType == typeof(HttpContext)) { arguments[parameterInfo.Index] = httpContext; } else { var argumentValue = _serializerHelper.DeserializeInputParameter( xmlReader, parameterType, parameterInfo.Name, operation.Contract.Namespace, parameterInfo.Parameter.Member, serviceKnownTypes); //fix https://github.com/DigDes/SoapCore/issues/379 (hack, need research) if (argumentValue == null) { argumentValue = _serializerHelper.DeserializeInputParameter( xmlReader, parameterType, parameterInfo.Name, parameterInfo.Namespace, parameterInfo.Parameter.Member, serviceKnownTypes); } arguments[parameterInfo.Index] = argumentValue; } } } else { // MessageContracts are constrained to having one "InParameter". We can do special logic on // for this Debug.Assert(operation.InParameters.Length == 1, "MessageContracts are constrained to having one 'InParameter'"); var parameterInfo = operation.InParameters[0]; var parameterType = parameterInfo.Parameter.ParameterType; var messageContractAttribute = parameterType.GetCustomAttribute <MessageContractAttribute>(); Debug.Assert(messageContractAttribute != null, "operation.IsMessageContractRequest should be false if this is null"); var @namespace = parameterInfo.Namespace ?? operation.Contract.Namespace; if (messageContractAttribute.IsWrapped && !parameterType.GetMembersWithAttribute <MessageHeaderAttribute>().Any()) { //https://github.com/DigDes/SoapCore/issues/385 if (operation.DispatchMethod.GetCustomAttribute <XmlSerializerFormatAttribute>()?.Style == OperationFormatStyle.Rpc) { var importer = new SoapReflectionImporter(@namespace); var map = new XmlReflectionMember { IsReturnValue = false, MemberName = parameterInfo.Name, MemberType = parameterType }; var mapping = importer.ImportMembersMapping(parameterInfo.Name, @namespace, new[] { map }, false, true); var serializer = XmlSerializer.FromMappings(new[] { mapping })[0]; var value = serializer.Deserialize(xmlReader); if (value is object[] o && o.Length > 0) { arguments[parameterInfo.Index] = o[0]; } } else { // It's wrapped so we treat it like normal! arguments[parameterInfo.Index] = _serializerHelper.DeserializeInputParameter( xmlReader, parameterInfo.Parameter.ParameterType, parameterInfo.Name, @namespace, parameterInfo.Parameter.Member, serviceKnownTypes); } } else { var messageHeadersMembers = parameterType.GetPropertyOrFieldMembers() .Where(x => x.GetCustomAttribute <MessageHeaderAttribute>() != null) .Select(mi => new { MemberInfo = mi, MessageHeaderMemberAttribute = mi.GetCustomAttribute <MessageHeaderAttribute>() }).ToArray(); var wrapperObject = Activator.CreateInstance(parameterInfo.Parameter.ParameterType); for (var i = 0; i < requestMessage.Headers.Count; i++) { var header = requestMessage.Headers[i]; var member = messageHeadersMembers.FirstOrDefault(x => x.MessageHeaderMemberAttribute.Name == header.Name || x.MemberInfo.Name == header.Name); if (member != null) { var reader = requestMessage.Headers.GetReaderAtHeader(i); var value = _serializerHelper.DeserializeInputParameter( reader, member.MemberInfo.GetPropertyOrFieldType(), member.MessageHeaderMemberAttribute.Name ?? member.MemberInfo.Name, member.MessageHeaderMemberAttribute.Namespace ?? @namespace, member.MemberInfo, serviceKnownTypes); member.MemberInfo.SetValueToPropertyOrField(wrapperObject, value); } } // This object isn't a wrapper element, so we will hunt for the nested message body // member inside of it var messageBodyMembers = parameterType.GetPropertyOrFieldMembers().Where(x => x.GetCustomAttribute <MessageBodyMemberAttribute>() != null).Select(mi => new { Member = mi, MessageBodyMemberAttribute = mi.GetCustomAttribute <MessageBodyMemberAttribute>() }).OrderBy(x => x.MessageBodyMemberAttribute.Order); if (messageContractAttribute.IsWrapped) { xmlReader.Read(); } foreach (var messageBodyMember in messageBodyMembers) { var messageBodyMemberAttribute = messageBodyMember.MessageBodyMemberAttribute; var messageBodyMemberInfo = messageBodyMember.Member; var innerParameterName = messageBodyMemberAttribute.Name ?? messageBodyMemberInfo.Name; var innerParameterNs = messageBodyMemberAttribute.Namespace ?? @namespace; var innerParameterType = messageBodyMemberInfo.GetPropertyOrFieldType(); //xmlReader.MoveToStartElement(innerParameterName, innerParameterNs); var innerParameter = _serializerHelper.DeserializeInputParameter( xmlReader, innerParameterType, innerParameterName, innerParameterNs, parameterInfo.Parameter.Member, serviceKnownTypes); messageBodyMemberInfo.SetValueToPropertyOrField(wrapperObject, innerParameter); } arguments[parameterInfo.Index] = wrapperObject; } } foreach (var parameterInfo in operation.OutParameters) { if (arguments[parameterInfo.Index] != null) { // do not overwrite input ref parameters continue; } if (parameterInfo.Parameter.ParameterType.Name == "Guid&") { arguments[parameterInfo.Index] = Guid.Empty; } else if (parameterInfo.Parameter.ParameterType.Name == "String&" || parameterInfo.Parameter.ParameterType.GetElementType().IsArray) { arguments[parameterInfo.Index] = null; } else { var type = parameterInfo.Parameter.ParameterType.GetElementType(); arguments[parameterInfo.Index] = Activator.CreateInstance(type); } } return(arguments); }
private static XmlMembersMapping ImportMembersMapping(XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, bool serviceDefaultIsEncoded, bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, string elementName, string elementNamespace, bool nsIsDefault, XmlReflectionMember[] members, bool validate, bool openModel, string key, bool writeAccess) { XmlMembersMapping mapping = null; if (use == SoapBindingUse.Encoded) { string ns = ((!rpc && (paramStyle != SoapParameterStyle.Bare)) && nsIsDefault) ? GetEncodedNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace; mapping = soapImporter.ImportMembersMapping(elementName, ns, members, rpc || (paramStyle != SoapParameterStyle.Bare), rpc, validate, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read); } else { string str2 = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace; mapping = xmlImporter.ImportMembersMapping(elementName, str2, members, paramStyle != SoapParameterStyle.Bare, rpc, openModel, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read); } if (mapping != null) { mapping.SetKey(key); } return(mapping); }