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;
}
