void ImportMessageParts() { SoapMethodStubInfo method = (SoapMethodStubInfo)MethodStubInfo; ImportMessage(method.InputMembersMapping, InputMessage); ImportMessage(method.OutputMembersMapping, OutputMessage); foreach (SoapHeaderMapping hf in method.Headers) { if (hf.Custom) { continue; } Message msg = new Message(); msg.Name = Operation.Name + hf.HeaderType.Name; MessagePart part = new MessagePart(); part.Name = hf.HeaderType.Name; msg.Parts.Add(part); ServiceDescription.Messages.Add(msg); if (method.Use == SoapBindingUse.Literal) { // MS.NET reflects header classes in a weird way. The root element // name is the CLR class name unless it is specified in an XmlRootAttribute. // The usual is to use the xml type name by default, but not in this case. XmlRootAttribute root; XmlAttributes ats = new XmlAttributes(hf.HeaderType); if (ats.XmlRoot != null) { root = ats.XmlRoot; } else { root = new XmlRootAttribute(hf.HeaderType.Name); } if (root.Namespace == null) { root.Namespace = TypeInfo.LogicalType.GetWebServiceLiteralNamespace(ServiceDescription.TargetNamespace); } if (root.ElementName == null) { root.ElementName = hf.HeaderType.Name; } XmlTypeMapping mapping = ReflectionImporter.ImportTypeMapping(hf.HeaderType, root); part.Element = new XmlQualifiedName(mapping.ElementName, mapping.Namespace); SchemaExporter.ExportTypeMapping(mapping); } else { XmlTypeMapping mapping = SoapReflectionImporter.ImportTypeMapping(hf.HeaderType, TypeInfo.LogicalType.GetWebServiceEncodedNamespace(ServiceDescription.TargetNamespace)); part.Type = new XmlQualifiedName(mapping.ElementName, mapping.Namespace); SoapSchemaExporter.ExportTypeMapping(mapping); } } }
public void Reflect(Type type, string url) { XmlSchemaExporter schemaExporter = new XmlSchemaExporter(Schemas); SoapSchemaExporter soapSchemaExporter = new SoapSchemaExporter(Schemas); if (WSConfig.IsSupported(WSProtocol.HttpSoap)) { new Soap11ProtocolReflector().Reflect(this, type, url, schemaExporter, soapSchemaExporter); } #if NET_2_0 if (WSConfig.IsSupported(WSProtocol.HttpSoap12)) { new Soap12ProtocolReflector().Reflect(this, type, url, schemaExporter, soapSchemaExporter); } #endif if (WSConfig.IsSupported(WSProtocol.HttpGet)) { new HttpGetProtocolReflector().Reflect(this, type, url, schemaExporter, soapSchemaExporter); } #if ONLY_1_1 if (WSConfig.IsSupported(WSProtocol.HttpPost) || WSConfig.IsSupported(WSProtocol.HttpPostLocalhost)) #else if (WSConfig.IsSupported(WSProtocol.HttpPost)) #endif { new HttpPostProtocolReflector().Reflect(this, type, url, schemaExporter, soapSchemaExporter); } int i = 0; while (i < types.Schemas.Count) { if (types.Schemas[i].Items.Count == 0) { types.Schemas.RemoveAt(i); } else { i++; } } if (serviceDescriptions.Count == 1) { serviceDescriptions[0].Types = types; } else { foreach (ServiceDescription d in serviceDescriptions) { d.Types = new Types(); for (int n = 0; n < types.Schemas.Count; n++) { ProtocolReflector.AddImport(d, types.Schemas[n].TargetNamespace, GetSchemaUrl(url, n)); } } } }
internal void Reflect(ServiceDescriptionReflector serviceReflector, Type type, string url, XmlSchemaExporter xxporter, SoapSchemaExporter sxporter) { portNames = new CodeIdentifiers(); this.serviceReflector = serviceReflector; serviceUrl = url; serviceType = type; schemaExporter = xxporter; soapSchemaExporter = sxporter; typeInfo = TypeStubManager.GetTypeStub(type, ProtocolName); ServiceDescription desc = ServiceDescriptions [typeInfo.LogicalType.WebServiceNamespace]; if (desc == null) { desc = new ServiceDescription(); desc.TargetNamespace = typeInfo.LogicalType.WebServiceNamespace; desc.Name = typeInfo.LogicalType.WebServiceName; ServiceDescriptions.Add(desc); } ImportService(desc, typeInfo, url); }
void ImportMessage(XmlMembersMapping members, Message msg) { SoapMethodStubInfo method = (SoapMethodStubInfo)MethodStubInfo; bool needsEnclosingElement = (method.ParameterStyle == SoapParameterStyle.Wrapped && method.SoapBindingStyle == SoapBindingStyle.Document); if (needsEnclosingElement) { MessagePart part = new MessagePart(); part.Name = "parameters"; XmlQualifiedName qname = new XmlQualifiedName(members.ElementName, members.Namespace); if (method.Use == SoapBindingUse.Literal) { part.Element = qname; } else { part.Type = qname; } msg.Parts.Add(part); } else { for (int n = 0; n < members.Count; n++) { MessagePart part = new MessagePart(); part.Name = members[n].MemberName; if (method.Use == SoapBindingUse.Literal) { if (members[n].Any) { part.Type = new XmlQualifiedName("any", members[n].Namespace); } else { part.Element = new XmlQualifiedName(members[n].ElementName, members[n].Namespace); } } else { string namesp = members[n].TypeNamespace; if (namesp == "") { namesp = members[n].Namespace; } part.Name = members[n].ElementName; part.Type = new XmlQualifiedName(members[n].TypeName, namesp); } msg.Parts.Add(part); } } if (method.Use == SoapBindingUse.Literal) { SchemaExporter.ExportMembersMapping(members); } else { SoapSchemaExporter.ExportMembersMapping(members, needsEnclosingElement); } }
protected override bool ReflectMethod() { LogicalTypeInfo ti = TypeStubManager.GetLogicalTypeInfo(ServiceType); HttpOperationBinding sob = new HttpOperationBinding(); sob.Location = "/" + MethodStubInfo.Name; OperationBinding.Extensions.Add(sob); if (!Method.IsVoid) { MimeXmlBinding mxb = new MimeXmlBinding(); mxb.Part = "Body"; OperationBinding.Output.Extensions.Add(mxb); MessagePart part = new MessagePart(); part.Name = "Body"; XmlTypeMapping map = ReflectionImporter.ImportTypeMapping(Method.ReturnType, ti.GetWebServiceLiteralNamespace(ServiceDescription.TargetNamespace)); XmlQualifiedName qname = new XmlQualifiedName(map.ElementName, map.Namespace); part.Element = qname; OutputMessage.Parts.Add(part); SchemaExporter.ExportTypeMapping(map); } XmlReflectionMember[] mems = new XmlReflectionMember [Method.Parameters.Length]; for (int n = 0; n < Method.Parameters.Length; n++) { ParameterInfo param = Method.Parameters [n]; XmlReflectionMember mem = new XmlReflectionMember(); mem.MemberName = param.Name; Type ptype = param.ParameterType; if (ptype.IsByRef) { ptype = ptype.GetElementType(); } mem.MemberType = ptype; mems [n] = mem; } XmlMembersMapping memap = ReflectionImporter.ImportMembersMapping("", ti.WebServiceAbstractNamespace, mems, false); bool allPrimitives = true; for (int n = 0; n < memap.Count; n++) { XmlMemberMapping mem = memap[n]; MessagePart part = new MessagePart(); XmlQualifiedName pqname; if (mem.TypeNamespace == "") { pqname = new XmlQualifiedName(mem.TypeName, XmlSchema.Namespace); } else { pqname = new XmlQualifiedName(mem.TypeName, mem.TypeNamespace); allPrimitives = false; } part.Type = pqname; part.Name = mem.ElementName; InputMessage.Parts.Add(part); } if (!allPrimitives) { SoapSchemaExporter.ExportMembersMapping(memap); } return(true); }