public SoapBodyBinding () { encoding = String.Empty; ns = String.Empty; parts = null; partsString = null; use = SoapBindingUse.Default; }
public SoapHeaderFaultBinding() { encoding = String.Empty; message = XmlQualifiedName.Empty; ns = String.Empty; part = String.Empty; use = SoapBindingUse.Default; }
public SoapHeaderFaultBinding () { encoding = String.Empty; message = XmlQualifiedName.Empty; ns = String.Empty; part = String.Empty; use = SoapBindingUse.Default; }
public SoapBodyBinding() { encoding = String.Empty; ns = String.Empty; parts = null; partsString = null; use = SoapBindingUse.Default; }
public SoapHeaderBinding () { encoding = String.Empty; mapToProperty = false; message = XmlQualifiedName.Empty; ns = String.Empty; part = String.Empty; use = SoapBindingUse.Default; }
public SoapHeaderBinding() { encoding = String.Empty; mapToProperty = false; message = XmlQualifiedName.Empty; ns = String.Empty; part = String.Empty; use = SoapBindingUse.Default; }
protected override SoapBodyBinding CreateSoapBodyBinding(SoapBindingUse use, string ns) { Soap12BodyBinding binding = new Soap12BodyBinding { Use = use }; if (use == SoapBindingUse.Encoded) { binding.Encoding = "http://www.w3.org/2003/05/soap-encoding"; } binding.Namespace = ns; return binding; }
protected virtual SoapBodyBinding CreateSoapBodyBinding(SoapBindingUse use, string ns) { SoapBodyBinding soapBodyBinding = new SoapBodyBinding(); soapBodyBinding.Use = use; if (use == SoapBindingUse.Encoded) { soapBodyBinding.Encoding = Soap.Encoding; } soapBodyBinding.Namespace = ns; return(soapBodyBinding); }
private void CreateMessage(bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, Message message, MessageBinding messageBinding, XmlMembersMapping members) { bool flag = paramStyle != SoapParameterStyle.Bare; if (use == SoapBindingUse.Encoded) { this.CreateEncodedMessage(message, messageBinding, members, flag && !rpc); } else { this.CreateLiteralMessage(message, messageBinding, members, flag && !rpc, rpc); } }
void CreateMessage(bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, Message message, MessageBinding messageBinding, XmlMembersMapping members) { bool wrapped = paramStyle != SoapParameterStyle.Bare; if (use == SoapBindingUse.Encoded) { CreateEncodedMessage(message, messageBinding, members, wrapped && !rpc); } else { CreateLiteralMessage(message, messageBinding, members, wrapped); } }
private string Write100_SoapBindingUse(SoapBindingUse v) { switch (v) { case SoapBindingUse.Encoded: return "encoded"; case SoapBindingUse.Literal: return "literal"; } long num = (long) v; throw base.CreateInvalidEnumValueException(num.ToString(CultureInfo.InvariantCulture), "System.Web.Services.Description.SoapBindingUse"); }
protected override SoapBodyBinding CreateSoapBodyBinding(SoapBindingUse use, string ns) { Soap12BodyBinding binding = new Soap12BodyBinding { Use = use }; if (use == SoapBindingUse.Encoded) { binding.Encoding = "http://www.w3.org/2003/05/soap-encoding"; } binding.Namespace = ns; return(binding); }
protected virtual SoapBodyBinding CreateSoapBodyBinding(SoapBindingUse use, string ns) { SoapBodyBinding binding = new SoapBodyBinding { Use = use }; if (use == SoapBindingUse.Encoded) { binding.Encoding = "http://schemas.xmlsoap.org/soap/encoding/"; } binding.Namespace = ns; return(binding); }
protected override SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, string ns, SoapBindingUse use) { Soap12HeaderBinding binding = new Soap12HeaderBinding { Message = message, Part = partName, Namespace = ns, Use = use }; if (use == SoapBindingUse.Encoded) { binding.Encoding = "http://www.w3.org/2003/05/soap-encoding"; } return binding; }
internal void RegisterHeaderType (Type type, string serviceNamespace, SoapBindingUse use) { Hashtable serializers = header_serializers [(int)use]; if (serializers == null) { serializers = new Hashtable (); header_serializers [(int)use] = serializers; header_serializers_byname [(int)use] = new Hashtable (); } if (serializers.ContainsKey (type)) return; XmlTypeMapping tm; if (use == SoapBindingUse.Literal) { XmlReflectionImporter ri = new XmlReflectionImporter (); // 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 (type); if (ats.XmlRoot != null) root = ats.XmlRoot; else root = new XmlRootAttribute (type.Name); if (root.Namespace == null) root.Namespace = LogicalType.GetWebServiceLiteralNamespace (serviceNamespace); if (root.ElementName == null) root.ElementName = type.Name; tm = ri.ImportTypeMapping (type, root); } else { SoapReflectionImporter ri = new SoapReflectionImporter (); tm = ri.ImportTypeMapping (type, LogicalType.GetWebServiceEncodedNamespace (serviceNamespace)); } int sid = RegisterSerializer (tm); serializers [type] = sid; header_serializers_byname [(int)use] [new XmlQualifiedName (tm.ElementName, tm.Namespace)] = sid; }
protected override SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, SoapBindingUse use) { return(CreateSoapHeaderBinding(message, partName, null, use)); }
protected override SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, string ns, SoapBindingUse use) { Soap12HeaderBinding binding = new Soap12HeaderBinding { Message = message, Part = partName, Namespace = ns, Use = use }; if (use == SoapBindingUse.Encoded) { binding.Encoding = "http://www.w3.org/2003/05/soap-encoding"; } return(binding); }
protected virtual SoapBodyBinding CreateSoapBodyBinding(SoapBindingUse use, string ns) { SoapBodyBinding soapBodyBinding = new SoapBodyBinding(); soapBodyBinding.Use = use; if (use == SoapBindingUse.Encoded) soapBodyBinding.Encoding = Soap.Encoding; soapBodyBinding.Namespace = ns; return soapBodyBinding; }
protected virtual SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, string ns, SoapBindingUse use) { SoapHeaderBinding soapHeaderBinding = new SoapHeaderBinding(); soapHeaderBinding.Message = message; soapHeaderBinding.Part = partName; soapHeaderBinding.Use = use; if (use == SoapBindingUse.Encoded) { soapHeaderBinding.Encoding = Soap.Encoding; soapHeaderBinding.Namespace = ns; } return soapHeaderBinding; }
public string GenerateHttpGetMessage(Port port, OperationBinding obin, Operation oper, OperationMessage msg) { string req = ""; if (msg is OperationInput) { HttpAddressBinding sab = port.Extensions.Find(typeof(HttpAddressBinding)) as HttpAddressBinding; HttpOperationBinding sob = obin.Extensions.Find(typeof(HttpOperationBinding)) as HttpOperationBinding; string location = new Uri(sab.Location).AbsolutePath + sob.Location + "?" + BuildQueryString(msg); req += "GET " + location + "\n"; req += "Host: " + GetLiteral("string"); } else { req += "HTTP/1.0 200 OK\n"; req += "Content-Type: text/xml; charset=utf-8\n"; req += "Content-Length: " + GetLiteral("string") + "\n\n"; MimeXmlBinding mxb = (MimeXmlBinding)obin.Output.Extensions.Find(typeof(MimeXmlBinding)) as MimeXmlBinding; if (mxb == null) return req; Message message = descriptions.GetMessage(msg.Message); XmlQualifiedName ename = null; foreach (MessagePart part in message.Parts) if (part.Name == mxb.Part) ename = part.Element; if (ename == null) return req + GetLiteral("string"); StringWriter sw = new StringWriter(); XmlTextWriter xtw = new XmlTextWriter(sw); xtw.Formatting = Formatting.Indented; currentUse = SoapBindingUse.Literal; WriteRootElementSample(xtw, ename); xtw.Close(); req += sw.ToString(); } return req; }
public SoapFaultBinding () { encoding = String.Empty; ns = String.Empty; use = SoapBindingUse.Default; }
private void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers, bool rpc) { if (use == SoapBindingUse.Encoded) { this.SoapExporter.ExportMembersMapping(inHeaderMappings, false); if (outHeaderMappings != null) { this.SoapExporter.ExportMembersMapping(outHeaderMappings, false); } } else { base.SchemaExporter.ExportMembersMapping(inHeaderMappings); if (outHeaderMappings != null) { base.SchemaExporter.ExportMembersMapping(outHeaderMappings); } } CodeIdentifiers identifiers = new CodeIdentifiers(); int num = 0; int num2 = 0; for (int i = 0; i < headers.Length; i++) { SoapReflectedHeader header = headers[i]; if (header.custom) { XmlMemberMapping mapping; Message message; if ((header.direction & SoapHeaderDirection.In) != 0) { mapping = inHeaderMappings[num++]; if (header.direction != SoapHeaderDirection.In) { num2++; } } else { mapping = outHeaderMappings[num2++]; } MessagePart messagePart = new MessagePart { Name = mapping.XsdElementName }; if (use == SoapBindingUse.Encoded) { messagePart.Type = new XmlQualifiedName(mapping.TypeName, mapping.TypeNamespace); } else { messagePart.Element = new XmlQualifiedName(mapping.XsdElementName, mapping.Namespace); } message = new Message { Name = identifiers.AddUnique(methodName + messagePart.Name, message) }; message.Parts.Add(messagePart); base.HeaderMessages.Add(message); ServiceDescriptionFormatExtension extension = this.CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, base.Binding.ServiceDescription.TargetNamespace), messagePart.Name, rpc ? mapping.Namespace : null, use); if ((header.direction & SoapHeaderDirection.In) != 0) { base.OperationBinding.Input.Extensions.Add(extension); } if ((header.direction & SoapHeaderDirection.Out) != 0) { base.OperationBinding.Output.Extensions.Add(extension); } if ((header.direction & SoapHeaderDirection.Fault) != 0) { if (this.soapMethod.IsClaimsConformance) { throw new InvalidOperationException(System.Web.Services.Res.GetString("BPConformanceHeaderFault", new object[] { this.soapMethod.methodInfo.ToString(), this.soapMethod.methodInfo.DeclaringType.FullName, "Direction", typeof(SoapHeaderDirection).Name, SoapHeaderDirection.Fault.ToString() })); } base.OperationBinding.Output.Extensions.Add(extension); } } } }
public SoapTypeStubInfo (LogicalTypeInfo logicalTypeInfo) : base (logicalTypeInfo) { xmlImporter = new XmlReflectionImporter (); soapImporter = new SoapReflectionImporter (); object [] o; o = Type.GetCustomAttributes (typeof (WebServiceBindingAttribute), false); if (typeof (SoapHttpClientProtocol).IsAssignableFrom (Type)) { if (o.Length == 0) throw new InvalidOperationException ("WebServiceBindingAttribute is required on proxy class '" + Type + "'."); if (o.Length > 1) throw new InvalidOperationException ("Only one WebServiceBinding attribute may be specified on type '" + Type + "'."); // Remove the default binding, it is not needed since there is always // a binding attribute. Bindings.Clear (); } foreach (WebServiceBindingAttribute at in o) AddBinding (new BindingInfo (at, LogicalType.WebServiceNamespace)); o = Type.GetCustomAttributes (typeof (SoapDocumentServiceAttribute), false); if (o.Length == 1){ SoapDocumentServiceAttribute a = (SoapDocumentServiceAttribute) o [0]; ParameterStyle = a.ParameterStyle; RoutingStyle = a.RoutingStyle; Use = a.Use; SoapBindingStyle = SoapBindingStyle.Document; } else { o = Type.GetCustomAttributes (typeof (SoapRpcServiceAttribute), false); if (o.Length == 1){ SoapRpcServiceAttribute srs = (SoapRpcServiceAttribute) o [0]; ParameterStyle = SoapParameterStyle.Wrapped; RoutingStyle = srs.RoutingStyle; Use = SoapBindingUse.Encoded; SoapBindingStyle = SoapBindingStyle.Rpc; } else { ParameterStyle = SoapParameterStyle.Wrapped; RoutingStyle = SoapServiceRoutingStyle.SoapAction; Use = SoapBindingUse.Literal; SoapBindingStyle = SoapBindingStyle.Document; } } if (ParameterStyle == SoapParameterStyle.Default) ParameterStyle = SoapParameterStyle.Wrapped; if (Use == SoapBindingUse.Default) Use = SoapBindingUse.Literal; xmlImporter.IncludeTypes (Type); soapImporter.IncludeTypes (Type); SoapExtensions = SoapExtension.GetTypeExtensions (Type); }
internal XmlSerializer GetHeaderSerializer (XmlQualifiedName qname, SoapBindingUse use) { Hashtable table = header_serializers_byname [(int)use]; if (table == null) return null; object serId = table [qname]; if (serId == null) return null; return GetSerializer ((int) serId); }
internal XmlSerializer GetHeaderSerializer (Type type, SoapBindingUse use) { Hashtable table = header_serializers [(int)use]; if (table == null) return null; return GetSerializer ((int) table [type]); }
/// <include file='doc\SoapDocumentServiceAttribute.uex' path='docs/doc[@for="SoapDocumentServiceAttribute.SoapDocumentServiceAttribute2"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public SoapDocumentServiceAttribute(SoapBindingUse use, SoapParameterStyle paramStyle) { this.use = use; this.paramStyle = paramStyle; }
/// <include file='doc\SoapDocumentServiceAttribute.uex' path='docs/doc[@for="SoapDocumentServiceAttribute.SoapDocumentServiceAttribute1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public SoapDocumentServiceAttribute(SoapBindingUse use) { this.use = use; }
void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers, bool rpc) { // if (use == SoapBindingUse.Encoded) { SoapExporter.ExportMembersMapping(inHeaderMappings, false); if (outHeaderMappings != null) { SoapExporter.ExportMembersMapping(outHeaderMappings, false); } } else { SchemaExporter.ExportMembersMapping(inHeaderMappings); if (outHeaderMappings != null) { SchemaExporter.ExportMembersMapping(outHeaderMappings); } } CodeIdentifiers identifiers = new CodeIdentifiers(); int inCount = 0, outCount = 0; for (int i = 0; i < headers.Length; i++) { SoapReflectedHeader soapHeader = headers[i]; if (!soapHeader.custom) { continue; } XmlMemberMapping member; if ((soapHeader.direction & SoapHeaderDirection.In) != 0) { member = inHeaderMappings[inCount++]; if (soapHeader.direction != SoapHeaderDirection.In) { outCount++; } } else { member = outHeaderMappings[outCount++]; } MessagePart part = new MessagePart(); part.Name = member.XsdElementName; if (use == SoapBindingUse.Encoded) { part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace); } else { part.Element = new XmlQualifiedName(member.XsdElementName, member.Namespace); } Message message = new Message(); message.Name = identifiers.AddUnique(methodName + part.Name, message); message.Parts.Add(part); HeaderMessages.Add(message); ServiceDescriptionFormatExtension soapHeaderBinding = CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, Binding.ServiceDescription.TargetNamespace), part.Name, rpc ? member.Namespace : null, use); if ((soapHeader.direction & SoapHeaderDirection.In) != 0) { OperationBinding.Input.Extensions.Add(soapHeaderBinding); } if ((soapHeader.direction & SoapHeaderDirection.Out) != 0) { OperationBinding.Output.Extensions.Add(soapHeaderBinding); } if ((soapHeader.direction & SoapHeaderDirection.Fault) != 0) { if (soapMethod.IsClaimsConformance) { throw new InvalidOperationException(Res.GetString(Res.BPConformanceHeaderFault, soapMethod.methodInfo.ToString(), soapMethod.methodInfo.DeclaringType.FullName, "Direction", typeof(SoapHeaderDirection).Name, SoapHeaderDirection.Fault.ToString())); } OperationBinding.Output.Extensions.Add(soapHeaderBinding); } } }
private void ImportReflectedMethod(SoapReflectedMethod soapMethod) { this.action = soapMethod.action; this.extensions = soapMethod.extensions; this.extensionInitializers = SoapReflectedExtension.GetInitializers(this.methodInfo, soapMethod.extensions); this.oneWay = soapMethod.oneWay; this.rpc = soapMethod.rpc; this.use = soapMethod.use; this.paramStyle = soapMethod.paramStyle; this.wsiClaims = soapMethod.binding == null ? WsiProfiles.None : soapMethod.binding.ConformsTo; }
// // 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); } InputMembersMapping.SetKey(RequestName); OutputMembersMapping.SetKey(ResponseName); 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); InputHeaderMembersMapping.SetKey(RequestName + ":InHeaders"); 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); OutputHeaderMembersMapping.SetKey(ResponseName + ":OutHeaders"); 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 string GenerateSoapMessage(OperationBinding obin, Operation oper, OperationMessage msg) { SoapOperationBinding sob = obin.Extensions.Find(typeof(SoapOperationBinding)) as SoapOperationBinding; SoapBindingStyle style = (sob != null) ? sob.Style : SoapBindingStyle.Document; MessageBinding msgbin = (msg is OperationInput) ? (MessageBinding)obin.Input : (MessageBinding)obin.Output; SoapBodyBinding sbb = msgbin.Extensions.Find(typeof(SoapBodyBinding)) as SoapBodyBinding; SoapBindingUse bodyUse = (sbb != null) ? sbb.Use : SoapBindingUse.Literal; StringWriter sw = new StringWriter(); XmlTextWriter xtw = new XmlTextWriter(sw); xtw.Formatting = Formatting.Indented; xtw.WriteStartDocument(); xtw.WriteStartElement("soap", "Envelope", SoapEnvelopeNamespace); xtw.WriteAttributeString("xmlns", "xsi", null, XmlSchema.InstanceNamespace); xtw.WriteAttributeString("xmlns", "xsd", null, XmlSchema.Namespace); if (bodyUse == SoapBindingUse.Encoded) { xtw.WriteAttributeString("xmlns", "soapenc", null, SoapEncodingNamespace); xtw.WriteAttributeString("xmlns", "tns", null, msg.Message.Namespace); } // Serialize headers bool writtenHeader = false; foreach (object ob in msgbin.Extensions) { SoapHeaderBinding hb = ob as SoapHeaderBinding; if (hb == null) continue; if (!writtenHeader) { xtw.WriteStartElement("soap", "Header", SoapEnvelopeNamespace); writtenHeader = true; } WriteHeader(xtw, hb); } if (writtenHeader) xtw.WriteEndElement(); // Serialize body xtw.WriteStartElement("soap", "Body", SoapEnvelopeNamespace); currentUse = bodyUse; WriteBody(xtw, oper, msg, sbb, style); xtw.WriteEndElement(); xtw.WriteEndElement(); xtw.Close(); return sw.ToString(); }
void GenerateReturnAttributes (XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeMemberMethod method) { if (use == SoapBindingUse.Literal) xmlExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, member, members.Namespace, (member.ElementName != method.Name + "Result")); else soapExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, member, (member.ElementName != method.Name + "Result")); }
void WriteHeader(XmlTextWriter xtw, SoapHeaderBinding header) { Message msg = descriptions.GetMessage(header.Message); if (msg == null) throw new InvalidOperationException("Message " + header.Message + " not found"); MessagePart part = msg.Parts[header.Part]; if (part == null) throw new InvalidOperationException("Message part " + header.Part + " not found in message " + header.Message); currentUse = header.Use; if (currentUse == SoapBindingUse.Literal) WriteRootElementSample(xtw, part.Element); else WriteTypeSample(xtw, part.Type); }
private void GenerateHeaders(CodeAttributeDeclarationCollection metadata, SoapBindingUse use, bool rpc, MessageBinding requestMessage, MessageBinding responseMessage) { Hashtable hashtable = new Hashtable(); for (int i = 0; i < 2; i++) { MessageBinding binding; SoapHeaderDirection @in; if (i == 0) { binding = requestMessage; @in = SoapHeaderDirection.In; } else { if (responseMessage == null) { continue; } binding = responseMessage; @in = SoapHeaderDirection.Out; } SoapHeaderBinding[] bindingArray = (SoapHeaderBinding[]) binding.Extensions.FindAll(typeof(SoapHeaderBinding)); foreach (SoapHeaderBinding binding2 in bindingArray) { if (binding2.MapToProperty) { XmlTypeMapping mapping; string str; if (use != binding2.Use) { throw new InvalidOperationException(System.Web.Services.Res.GetString("WebDescriptionHeaderAndBodyUseMismatch")); } if ((use == SoapBindingUse.Encoded) && !this.IsSoapEncodingPresent(binding2.Encoding)) { throw new InvalidOperationException(System.Web.Services.Res.GetString("WebUnknownEncodingStyle", new object[] { binding2.Encoding })); } Message message = base.ServiceDescriptions.GetMessage(binding2.Message); if (message == null) { throw new InvalidOperationException(System.Web.Services.Res.GetString("MissingMessage2", new object[] { binding2.Message.Name, binding2.Message.Namespace })); } MessagePart part = message.FindPartByName(binding2.Part); if (part == null) { throw new InvalidOperationException(System.Web.Services.Res.GetString("MissingMessagePartForMessageFromNamespace3", new object[] { part.Name, binding2.Message.Name, binding2.Message.Namespace })); } if (use == SoapBindingUse.Encoded) { if (part.Type.IsEmpty) { throw new InvalidOperationException(System.Web.Services.Res.GetString("WebDescriptionPartTypeRequired", new object[] { part.Name, binding2.Message.Name, binding2.Message.Namespace })); } if (!part.Element.IsEmpty) { base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("WebDescriptionPartElementWarning", new object[] { part.Name, binding2.Message.Name, binding2.Message.Namespace })); } mapping = this.soapImporter.ImportDerivedTypeMapping(part.Type, typeof(SoapHeader), true); str = "type=" + part.Type.ToString(); } else { if (part.Element.IsEmpty) { throw new InvalidOperationException(System.Web.Services.Res.GetString("WebDescriptionPartElementRequired", new object[] { part.Name, binding2.Message.Name, binding2.Message.Namespace })); } if (!part.Type.IsEmpty) { base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("WebDescriptionPartTypeWarning", new object[] { part.Name, binding2.Message.Name, binding2.Message.Namespace })); } mapping = this.xmlImporter.ImportDerivedTypeMapping(part.Element, typeof(SoapHeader), true); str = "element=" + part.Element.ToString(); } LocalSoapHeader header = (LocalSoapHeader) hashtable[str]; if (header == null) { GlobalSoapHeader header2 = (GlobalSoapHeader) this.classHeaders[str]; if (header2 == null) { header2 = new GlobalSoapHeader { isEncoded = use == SoapBindingUse.Encoded }; string identifier = CodeIdentifier.MakeValid(mapping.ElementName); if (identifier == mapping.TypeName) { identifier = identifier + "Value"; } identifier = base.MethodNames.AddUnique(identifier, mapping); header2.fieldName = identifier; WebCodeGenerator.AddMember(base.CodeTypeDeclaration, mapping.TypeFullName, header2.fieldName, null, null, CodeFlags.IsPublic, base.ServiceImporter.CodeGenerationOptions); header2.mapping = mapping; this.classHeaders.Add(str, header2); if (this.headers[str] == null) { this.headers.Add(str, header2); } } header = new LocalSoapHeader { fieldName = header2.fieldName, direction = @in }; hashtable.Add(str, header); } else if (header.direction != @in) { header.direction = SoapHeaderDirection.InOut; } } } } foreach (LocalSoapHeader header3 in hashtable.Values) { this.BeginMetadata(); if (header3.direction == SoapHeaderDirection.Out) { this.AddMetadataProperty("Direction", (CodeExpression) new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(SoapHeaderDirection).FullName), SoapHeaderDirection.Out.ToString())); } else if (header3.direction == SoapHeaderDirection.InOut) { this.AddMetadataProperty("Direction", (CodeExpression) new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(SoapHeaderDirection).FullName), SoapHeaderDirection.InOut.ToString())); } this.EndMetadata(metadata, typeof(SoapHeaderAttribute), header3.fieldName); } }
protected virtual SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, string ns, SoapBindingUse use) { SoapHeaderBinding binding = new SoapHeaderBinding { Message = message, Part = partName, Use = use }; if (use == SoapBindingUse.Encoded) { binding.Encoding = "http://schemas.xmlsoap.org/soap/encoding/"; binding.Namespace = ns; } return(binding); }
protected override SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, string ns, SoapBindingUse use) { Soap12HeaderBinding soapHeaderBinding = new Soap12HeaderBinding(); soapHeaderBinding.Message = message; soapHeaderBinding.Part = partName; soapHeaderBinding.Namespace = ns; soapHeaderBinding.Use = use; if (use == SoapBindingUse.Encoded) { soapHeaderBinding.Encoding = Soap12.Encoding; } return(soapHeaderBinding); }
protected virtual SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, SoapBindingUse use) { return(this.CreateSoapHeaderBinding(message, partName, null, use)); }
protected virtual SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, SoapBindingUse use) { SoapHeaderBinding soapHeaderBinding = new SoapHeaderBinding(); soapHeaderBinding.Message = message; soapHeaderBinding.Part = partName; soapHeaderBinding.Use = use; if (use == SoapBindingUse.Encoded) { soapHeaderBinding.Encoding = Soap.Encoding; } return(soapHeaderBinding); }
public SoapFaultBinding() { encoding = String.Empty; ns = String.Empty; use = SoapBindingUse.Default; }
void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers) { // CONSIDER, alexdej: support headerfault. if (use == SoapBindingUse.Encoded) { SoapExporter.ExportMembersMapping(inHeaderMappings, false); if (outHeaderMappings != null) { SoapExporter.ExportMembersMapping(outHeaderMappings, false); } } else { SchemaExporter.ExportMembersMapping(inHeaderMappings); if (outHeaderMappings != null) { SchemaExporter.ExportMembersMapping(outHeaderMappings); } } CodeIdentifiers identifiers = new CodeIdentifiers(); int inCount = 0, outCount = 0; for (int i = 0; i < headers.Length; i++) { SoapReflectedHeader soapHeader = headers[i]; if (!soapHeader.custom) { continue; } XmlMemberMapping member; if ((soapHeader.direction & SoapHeaderDirection.In) != 0) { member = inHeaderMappings[inCount++]; if (soapHeader.direction != SoapHeaderDirection.In) { outCount++; } } else { member = outHeaderMappings[outCount++]; } MessagePart part = new MessagePart(); part.Name = member.ElementName; if (use == SoapBindingUse.Encoded) { part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace); } else { part.Element = new XmlQualifiedName(member.ElementName, member.Namespace); } Message message = new Message(); message.Name = identifiers.AddUnique(methodName + part.Name, message); message.Parts.Add(part); HeaderMessages.Add(message); ServiceDescriptionFormatExtension soapHeaderBinding = CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, Binding.ServiceDescription.TargetNamespace), part.Name, use); if ((soapHeader.direction & SoapHeaderDirection.In) != 0) { OperationBinding.Input.Extensions.Add(soapHeaderBinding); } if ((soapHeader.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0) { OperationBinding.Output.Extensions.Add(soapHeaderBinding); } } }
void GenerateMemberAttributes (XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeParameterDeclarationExpression param) { if (use == SoapBindingUse.Literal) xmlExporter.AddMappingMetadata (param.CustomAttributes, member, members.Namespace); else soapExporter.AddMappingMetadata (param.CustomAttributes, member); }
void GenerateMemberAttributes(XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeParameterDeclarationExpression param) { if (use == SoapBindingUse.Literal) { xmlExporter.AddMappingMetadata(param.CustomAttributes, member, members.Namespace); } else { soapExporter.AddMappingMetadata(param.CustomAttributes, member); } }
void CreateMessage(bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, Message message, MessageBinding messageBinding, XmlMembersMapping members) { bool wrapped = paramStyle != SoapParameterStyle.Bare; if (use == SoapBindingUse.Encoded) CreateEncodedMessage(message, messageBinding, members, wrapped && !rpc); else CreateLiteralMessage(message, messageBinding, members, wrapped && !rpc, rpc); }
internal string GetWebServiceNamespace (string baseNamespace, SoapBindingUse use) { if (use == SoapBindingUse.Literal) return GetWebServiceLiteralNamespace (baseNamespace); else return GetWebServiceEncodedNamespace (baseNamespace); }
protected virtual SoapHeaderBinding CreateSoapHeaderBinding(XmlQualifiedName message, string partName, SoapBindingUse use) { return CreateSoapHeaderBinding(message, partName, null, use); }
public LogicalTypeInfo (Type t) { this.Type = t; object [] o = Type.GetCustomAttributes (typeof (WebServiceAttribute), false); if (o.Length == 1){ WebServiceAttribute a = (WebServiceAttribute) o [0]; WebServiceName = (a.Name != string.Empty) ? a.Name : Type.Name; WebServiceNamespace = (a.Namespace != string.Empty) ? a.Namespace : WebServiceAttribute.DefaultNamespace; Description = a.Description; } else { WebServiceName = Type.Name; WebServiceNamespace = WebServiceAttribute.DefaultNamespace; } // Determine the namespaces for literal and encoded schema types bindingUse = SoapBindingUse.Literal; o = t.GetCustomAttributes (typeof(SoapDocumentServiceAttribute), true); if (o.Length > 0) { SoapDocumentServiceAttribute at = (SoapDocumentServiceAttribute) o[0]; bindingUse = at.Use; if (bindingUse == SoapBindingUse.Default) bindingUse = SoapBindingUse.Literal; routingStyle = at.RoutingStyle; } else if (t.GetCustomAttributes (typeof(SoapRpcServiceAttribute), true).Length > 0) { o = t.GetCustomAttributes (typeof(SoapRpcServiceAttribute), true); SoapRpcServiceAttribute at = (SoapRpcServiceAttribute) o[0]; #if NET_2_0 bindingUse = at.Use; #else bindingUse = SoapBindingUse.Encoded; #endif routingStyle = at.RoutingStyle; if (bindingUse == SoapBindingUse.Default) bindingUse = SoapBindingUse.Encoded; } else routingStyle = SoapServiceRoutingStyle.SoapAction; string sep = WebServiceNamespace.EndsWith ("/") ? "" : "/"; WebServiceAbstractNamespace = WebServiceNamespace + sep + "AbstractTypes"; #if NET_2_0 MethodInfo [] type_methods; if (typeof (WebClientProtocol).IsAssignableFrom (Type)) type_methods = Type.GetMethods (BindingFlags.Instance | BindingFlags.Public); else { MethodInfo [] all_type_methods = Type.GetMethods (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); ArrayList list = new ArrayList (all_type_methods.Length); foreach (MethodInfo mi in all_type_methods) { if (mi.IsPublic && mi.GetCustomAttributes (typeof (WebMethodAttribute), false).Length > 0) list.Add (mi); else { foreach (Type ifaceType in Type.GetInterfaces ()) { if (ifaceType.GetCustomAttributes (typeof (WebServiceBindingAttribute), false).Length > 0) { MethodInfo found = FindInInterface (ifaceType, mi); if (found != null) { if (found.GetCustomAttributes (typeof (WebMethodAttribute), false).Length > 0) list.Add (found); break; } } } } } type_methods = (MethodInfo []) list.ToArray (typeof (MethodInfo)); } #else MethodInfo [] type_methods = Type.GetMethods (BindingFlags.Instance | BindingFlags.Public); #endif logicalMethods = LogicalMethodInfo.Create (type_methods, LogicalMethodTypes.Sync); }
void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers, bool rpc) { // if (use == SoapBindingUse.Encoded) { SoapExporter.ExportMembersMapping(inHeaderMappings, false); if (outHeaderMappings != null) SoapExporter.ExportMembersMapping(outHeaderMappings, false); } else { SchemaExporter.ExportMembersMapping(inHeaderMappings); if (outHeaderMappings != null) SchemaExporter.ExportMembersMapping(outHeaderMappings); } CodeIdentifiers identifiers = new CodeIdentifiers(); int inCount = 0, outCount = 0; for (int i = 0; i < headers.Length; i++) { SoapReflectedHeader soapHeader = headers[i]; if (!soapHeader.custom) continue; XmlMemberMapping member; if ((soapHeader.direction & SoapHeaderDirection.In) != 0) { member = inHeaderMappings[inCount++]; if (soapHeader.direction != SoapHeaderDirection.In) outCount++; } else { member = outHeaderMappings[outCount++]; } MessagePart part = new MessagePart(); part.Name = member.XsdElementName; if (use == SoapBindingUse.Encoded) part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace); else part.Element = new XmlQualifiedName(member.XsdElementName, member.Namespace); Message message = new Message(); message.Name = identifiers.AddUnique(methodName + part.Name, message); message.Parts.Add(part); HeaderMessages.Add(message); ServiceDescriptionFormatExtension soapHeaderBinding = CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, Binding.ServiceDescription.TargetNamespace), part.Name, rpc ? member.Namespace : null, use); if ((soapHeader.direction & SoapHeaderDirection.In) != 0) OperationBinding.Input.Extensions.Add(soapHeaderBinding); if ((soapHeader.direction & SoapHeaderDirection.Out) != 0) OperationBinding.Output.Extensions.Add(soapHeaderBinding); if ((soapHeader.direction & SoapHeaderDirection.Fault) != 0) { if (soapMethod.IsClaimsConformance) { throw new InvalidOperationException(Res.GetString(Res.BPConformanceHeaderFault, soapMethod.methodInfo.ToString(), soapMethod.methodInfo.DeclaringType.FullName, "Direction", typeof(SoapHeaderDirection).Name, SoapHeaderDirection.Fault.ToString())); } OperationBinding.Output.Extensions.Add(soapHeaderBinding); } } }
static SoapHeaderCollection ReadHeaders (SoapTypeStubInfo typeStubInfo, SoapBindingUse methodUse, XmlTextReader xmlReader) { SoapHeaderCollection headers = new SoapHeaderCollection (); while (! (xmlReader.NodeType == XmlNodeType.Element && xmlReader.LocalName == "Body" && xmlReader.NamespaceURI == WebServiceHelper.SoapEnvelopeNamespace)) { if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.LocalName == "Header" && xmlReader.NamespaceURI == WebServiceHelper.SoapEnvelopeNamespace && !xmlReader.IsEmptyElement) { xmlReader.ReadStartElement (); xmlReader.MoveToContent (); while (xmlReader.NodeType != XmlNodeType.Element && xmlReader.NodeType != XmlNodeType.EndElement) xmlReader.Skip (); xmlReader.MoveToContent (); if (xmlReader.NodeType == XmlNodeType.Element) { XmlQualifiedName qname = new XmlQualifiedName (xmlReader.LocalName, xmlReader.NamespaceURI); XmlSerializer headerSerializer = typeStubInfo.GetHeaderSerializer (qname, methodUse); if (headerSerializer != null) { SoapHeader header = (SoapHeader) headerSerializer.Deserialize (xmlReader); headers.Add (header); } else { XmlDocument doc = new XmlDocument (); XmlElement elem = (XmlElement) doc.ReadNode (xmlReader); headers.Add (new SoapUnknownHeader (elem)); } } while (xmlReader.NodeType != XmlNodeType.EndElement) xmlReader.Skip (); xmlReader.ReadEndElement (); } else xmlReader.Skip (); } return headers; }
void GenerateReturnAttributes(XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeMemberMethod method) { if (use == SoapBindingUse.Literal) { xmlExporter.AddMappingMetadata(method.ReturnTypeCustomAttributes, member, members.Namespace, (member.ElementName != method.Name + "Result")); } else { soapExporter.AddMappingMetadata(method.ReturnTypeCustomAttributes, member, (member.ElementName != method.Name + "Result")); } }
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 ns = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace; mapping = xmlImporter.ImportMembersMapping(elementName, ns, members, paramStyle != SoapParameterStyle.Bare, rpc, openModel, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read); } if (mapping != null) { mapping.SetKey(key); } return mapping; }