private TreeNode MessageToTreeNode(OperationMessage omsg, SoapBindingUse use)
{
Message msg=_services.GetMessage (omsg.Message);
TreeNode node=new TreeNode() ;
SchemaParser ngen=new SchemaParser(_schemas);
ngen.BindingUse=use;
foreach (MessagePart part in msg.Parts)
{
if (part.Element == XmlQualifiedName.Empty)
{
TreeNode partNode=ngen.Translate(part.Type);
partNode.ImageIndex=5;
partNode.SelectedImageIndex=5;
partNode.Text=part.Name;
node.Nodes.Add(partNode);
}
else
{
TreeNode partNode=ngen.Translate(part.Element);
partNode.ImageIndex=5;
partNode.SelectedImageIndex=5;
partNode.Text=part.Name;
node.Nodes.Add(partNode);
}
}
return node;
}
void GetOperationFormat(OperationBinding obin, out SoapBindingStyle style, out SoapBindingUse inputUse, out SoapBindingUse outputUse)
{
style = SoapBindingStyle.Document;
inputUse = SoapBindingUse.Literal;
outputUse = SoapBindingUse.Literal;
if (obin.Extensions != null)
{
SoapOperationBinding sob = obin.Extensions.Find(typeof(SoapOperationBinding)) as SoapOperationBinding;
if (sob != null)
{
style = sob.Style;
if (obin.Input != null)
{
SoapBodyBinding sbb0 = obin.Input.Extensions.Find(typeof(SoapBodyBinding)) as SoapBodyBinding;
if (sbb0 != null)
{
inputUse = sbb0.Use;
}
}
if (obin.Output != null)
{
SoapBodyBinding sbb1 = obin.Output.Extensions.Find(typeof(SoapBodyBinding)) as SoapBodyBinding;
if (sbb1 != null)
{
outputUse = sbb1.Use;
}
}
}
}
}
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);
}
}
public static void WriteSoapMessage(XmlTextWriter xtw, SoapMethodStubInfo method, SoapHeaderDirection dir, object bodyContent, SoapHeaderCollection headers, bool soap12)
{
SoapBindingUse methodUse = dir == SoapHeaderDirection.Fault ? SoapBindingUse.Literal : method.Use;
XmlSerializer bodySerializer = method.GetBodySerializer(dir, soap12);
XmlSerializer headerSerializer = method.GetHeaderSerializer(dir);
object[] headerArray = method.GetHeaderValueArray(dir, headers);
WriteSoapMessage(xtw, methodUse, bodySerializer, headerSerializer, bodyContent, headerArray, soap12);
}
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;
}
internal string GetWebServiceNamespace(string baseNamespace, SoapBindingUse use)
{
if (use == SoapBindingUse.Literal)
{
return(GetWebServiceLiteralNamespace(baseNamespace));
}
else
{
return(GetWebServiceEncodedNamespace(baseNamespace));
}
}
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);
}
static void WriteSoapMessage(XmlTextWriter xtw, Object methodStubInfo, SoapHeaderDirection dir, object bodyContent, SoapHeaderCollection headers, bool soap12)
{
SoapBindingUse use = (SoapBindingUse)ReflectionHelper.GetFieldValue(methodStubInfo, "Use");
SoapBindingUse methodUse = dir == SoapHeaderDirection.Fault ? SoapBindingUse.Literal : use;
XmlSerializer bodySerializer = (XmlSerializer)ReflectionHelper.ExecuteMethod(methodStubInfo, "GetBodySerializer", null, dir, soap12);
XmlSerializer headerSerializer = (XmlSerializer)ReflectionHelper.ExecuteMethod(methodStubInfo, "GetHeaderSerializer", null, dir);
object[] headerArray = (object[])ReflectionHelper.ExecuteMethod(methodStubInfo, "GetHeaderValueArray", null, dir, headers);
string ns = soap12 ? Soap12EnvelopeNamespace : SoapEnvelopeNamespace;
string encNS = soap12 ? Soap12EncodingNamespace : SoapEncodingNamespace;
xtw.WriteStartDocument();
xtw.WriteStartElement("soap", "Envelope", ns);
xtw.WriteAttributeString("xmlns", "xsi", null, XmlSchema.InstanceNamespace);
xtw.WriteAttributeString("xmlns", "xsd", null, XmlSchema.Namespace);
// Serialize headers
if (headerArray != null)
{
xtw.WriteStartElement("soap", "Header", ns);
headerSerializer.Serialize(xtw, headerArray);
xtw.WriteEndElement();
}
// Serialize body
xtw.WriteStartElement("soap", "Body", ns);
if (methodUse == SoapBindingUse.Encoded)
{
xtw.WriteAttributeString("encodingStyle", ns, encNS);
}
bodySerializer.Serialize(xtw, bodyContent);
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.Flush();
}
public static void WriteSoapMessage(XmlTextWriter xtw, SoapBindingUse methodUse, XmlSerializer bodySerializer, XmlSerializer headerSerializer, object bodyContent, object[] headers, bool soap12)
{
string ns = soap12 ?
WebServiceHelper.Soap12EnvelopeNamespace :
WebServiceHelper.SoapEnvelopeNamespace;
string encNS = soap12 ?
WebServiceHelper.Soap12EncodingNamespace :
WebServiceHelper.SoapEncodingNamespace;
xtw.WriteStartDocument();
xtw.WriteStartElement("soap", "Envelope", ns);
xtw.WriteAttributeString("xmlns", "xsi", null, XmlSchema.InstanceNamespace);
xtw.WriteAttributeString("xmlns", "xsd", null, XmlSchema.Namespace);
// Serialize headers
if (headers != null)
{
xtw.WriteStartElement("soap", "Header", ns);
headerSerializer.Serialize(xtw, headers);
xtw.WriteEndElement();
}
// Serialize body
xtw.WriteStartElement("soap", "Body", ns);
if (methodUse == SoapBindingUse.Encoded)
{
xtw.WriteAttributeString("encodingStyle", ns, encNS);
}
bodySerializer.Serialize(xtw, bodyContent);
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.Flush();
}
public SoapDocumentServiceAttribute(SoapBindingUse use)
{
this.use = use;
}
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());
}
static XmlMembersMapping ImportMembersMapping(XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, bool serviceDefaultIsEncoded, bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle,
string elementName, string elementNamespace, bool nsIsDefault, XmlReflectionMember[] members, bool validate)
{
if (use == SoapBindingUse.Encoded)
{
string ns = (!rpc && paramStyle != SoapParameterStyle.Bare && nsIsDefault) ? GetEncodedNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
return(soapImporter.ImportMembersMapping(elementName, ns, members, rpc || paramStyle != SoapParameterStyle.Bare, rpc, validate));
}
else
{
string ns = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
return(xmlImporter.ImportMembersMapping(elementName, ns, members, paramStyle != SoapParameterStyle.Bare));
}
}
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);
}
private void GetOperationFormat(OperationBinding obin, Operation oper, out SoapBindingStyle style,out SoapBindingUse inputUse, out SoapBindingUse outputUse, out string requestMessage, out string responseMessage, out TreeNode requestNode,out TreeNode responseNode)
{
style=SoapBindingStyle.Document;
outputUse=SoapBindingUse.Literal;
inputUse=SoapBindingUse.Literal;
requestMessage=string.Empty;
responseMessage=string.Empty;
requestNode=null;
responseNode=null;
SoapBindingStyle pStyle;
SoapBindingUse pInputUse, pOutputUse;
GetOperationFormat (obin, out pStyle, out pInputUse, out pOutputUse );
if (oper.Messages.Input != null){
requestNode=MessageToTreeNode(oper.Messages.Input, pInputUse);
}
if (oper.Messages.Output != null){
responseNode=MessageToTreeNode(oper.Messages.Output, pOutputUse );
}
style=pStyle;
outputUse=pOutputUse;
inputUse=pInputUse;
}
public TreeNode TranslateOperation(Port port, OperationBinding obin, Operation oper, string protocol)
{
TreeNode tnOperation=new TreeNode (oper.Name, 13 , 13);
SoapBindingStyle style=new SoapBindingStyle() ;
SoapBindingUse inputUse=new SoapBindingUse() ;
SoapBindingUse outputUse=new SoapBindingUse() ;
string requestmsg=string.Empty;
string responsemsg=string.Empty;
TreeNode tnInput=new TreeNode ();
TreeNode tnOutput=new TreeNode ();
TreeNode tnFault=new TreeNode ("Faults");
GetOperationFormat (obin, oper, out style,out inputUse,out outputUse, out requestmsg, out responsemsg,out tnInput, out tnOutput);
string operDesc=string.Empty;
operDesc +=oper.Documentation + "\n";
operDesc +="Style: " + style.ToString() + "\n" ;
tnOperation.Tag=operDesc;
MessageCollection messages=_services[0].Messages;
if (oper.Messages.Input != null)
{
Message messageIn=messages[oper.Messages.Input.Message.Name] ; if (messageIn != null )
{
if (tnInput == null) tnInput=new TreeNode() ;
tnInput.Tag=requestmsg;
tnInput.ImageIndex=13;
tnInput.SelectedImageIndex=13;
if (oper.Messages.Input.Name != null && oper.Messages.Input.Name != string.Empty)
{
tnInput.Text="Input: " + oper.Messages.Input.Name ;
}
Else{
tnInput.Text="Input: " + oper.Messages.Input.Message.Name ;
if (tnInput != null) tnOperation.Nodes.Add (tnInput );
};
};
if (oper.Messages.Output != null)
{
Message messageOut=messages[oper.Messages.Output.Message.Name] ;
if (messageOut != null )
{
if (tnOutput == null) tnOutput=new TreeNode() ;
tnOutput.Tag=responsemsg;
tnOutput.ImageIndex=13;
tnOutput.SelectedImageIndex=13;
if (oper.Messages.Output.Name != null && oper.Messages.Output.Name != string.Empty)
{
tnOutput.Text="Output: " + oper.Messages.Output.Name ;
}
else
tnOutput.Text="Output: " + oper.Messages.Output.Message.Name ;
if (tnOutput != null) tnOperation.Nodes.Add (tnOutput );
};
};
foreach (OperationFault faultOp in oper.Faults)
{
Message messageFault=messages[faultOp.Message.Name] ;
if (messageFault != null )
{
TreeNode treeNode=new TreeNode() ;
tnFault.ImageIndex=14;
tnFault.SelectedImageIndex=14;
if (treeNode != null)
tnFault.Nodes.Add (treeNode);
};
};
if (tnFault.Nodes.Count > 0 ) tnOperation.Nodes.Add (tnFault );
return tnOperation;
}
public SoapDocumentServiceAttribute()
{
paramStyle = SoapParameterStyle.Wrapped;
routingStyle = SoapServiceRoutingStyle.SoapAction;
use = SoapBindingUse.Literal;
}
public SoapDocumentServiceAttribute(SoapBindingUse use, SoapParameterStyle paramStyle)
{
this.use = use;
this.paramStyle = paramStyle;
}
public SoapRpcMethodAttribute()
{
this.use = SoapBindingUse.Encoded;
}
public SoapRpcMethodAttribute(string action)
{
this.use = SoapBindingUse.Encoded;
this.action = action;
}
//
// Constructor
//
public SoapMethodStubInfo(TypeStubInfo typeStub, LogicalMethodInfo source, object kind, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter)
: base(typeStub, source)
{
SoapTypeStubInfo parent = (SoapTypeStubInfo)typeStub;
XmlElementAttribute optional_ns = null;
if (kind == null)
{
Use = parent.LogicalType.BindingUse;
RequestName = "";
RequestNamespace = "";
ResponseName = "";
ResponseNamespace = "";
ParameterStyle = parent.ParameterStyle;
SoapBindingStyle = parent.SoapBindingStyle;
OneWay = false;
// disabled (see bug #332150)
//#if NET_2_0
// if (parent.Type != source.DeclaringType)
// Binding = source.DeclaringType.Name + parent.ProtocolName;
//#endif
}
else if (kind is SoapDocumentMethodAttribute)
{
SoapDocumentMethodAttribute dma = (SoapDocumentMethodAttribute)kind;
Use = dma.Use;
if (Use == SoapBindingUse.Default)
{
if (parent.SoapBindingStyle == SoapBindingStyle.Document)
{
Use = parent.LogicalType.BindingUse;
}
else
{
Use = SoapBindingUse.Literal;
}
}
Action = dma.Action;
Binding = dma.Binding;
RequestName = dma.RequestElementName;
RequestNamespace = dma.RequestNamespace;
ResponseName = dma.ResponseElementName;
ResponseNamespace = dma.ResponseNamespace;
ParameterStyle = dma.ParameterStyle;
if (ParameterStyle == SoapParameterStyle.Default)
{
ParameterStyle = parent.ParameterStyle;
}
OneWay = dma.OneWay;
SoapBindingStyle = SoapBindingStyle.Document;
}
else
{
SoapRpcMethodAttribute rma = (SoapRpcMethodAttribute)kind;
Use = SoapBindingUse.Encoded; // RPC always use encoded
Action = rma.Action;
if (Action != null && Action.Length == 0)
{
Action = null;
}
Binding = rma.Binding;
// When using RPC, MS.NET seems to ignore RequestElementName and
// MessageName, and it always uses the method name
RequestName = source.Name;
ResponseName = source.Name + "Response";
// RequestName = rma.RequestElementName;
// ResponseName = rma.ResponseElementName;
RequestNamespace = rma.RequestNamespace;
ResponseNamespace = rma.ResponseNamespace;
ParameterStyle = SoapParameterStyle.Wrapped;
OneWay = rma.OneWay;
SoapBindingStyle = SoapBindingStyle.Rpc;
// For RPC calls, make all arguments be part of the empty namespace
optional_ns = new XmlElementAttribute();
optional_ns.Namespace = "";
}
if (OneWay)
{
if (source.ReturnType != typeof(void))
{
throw new Exception("OneWay methods should not have a return value.");
}
if (source.OutParameters.Length != 0)
{
throw new Exception("OneWay methods should not have out/ref parameters.");
}
}
BindingInfo binfo = parent.GetBinding(Binding);
if (binfo == null)
{
throw new InvalidOperationException("Type '" + parent.Type + "' is missing WebServiceBinding attribute that defines a binding named '" + Binding + "'.");
}
string serviceNamespace = binfo.Namespace;
if (RequestNamespace == "")
{
RequestNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use);
}
if (ResponseNamespace == "")
{
ResponseNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use);
}
if (RequestName == "")
{
RequestName = Name;
}
if (ResponseName == "")
{
ResponseName = Name + "Response";
}
if (Action == null)
{
Action = serviceNamespace.EndsWith("/") ? (serviceNamespace + Name) : (serviceNamespace + "/" + Name);
}
bool hasWrappingElem = (ParameterStyle == SoapParameterStyle.Wrapped);
bool writeAccessors = (SoapBindingStyle == SoapBindingStyle.Rpc);
XmlReflectionMember [] in_members = BuildRequestReflectionMembers(optional_ns);
XmlReflectionMember [] out_members = BuildResponseReflectionMembers(optional_ns);
if (Use == SoapBindingUse.Literal)
{
xmlImporter.IncludeTypes(source.CustomAttributeProvider);
InputMembersMapping = xmlImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem);
OutputMembersMapping = xmlImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem);
}
else
{
soapImporter.IncludeTypes(source.CustomAttributeProvider);
InputMembersMapping = soapImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem, writeAccessors);
OutputMembersMapping = soapImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem, writeAccessors);
}
requestSerializerId = parent.RegisterSerializer(InputMembersMapping);
responseSerializerId = parent.RegisterSerializer(OutputMembersMapping);
object[] o = source.GetCustomAttributes(typeof(SoapHeaderAttribute));
ArrayList allHeaderList = new ArrayList(o.Length);
ArrayList inHeaderList = new ArrayList(o.Length);
ArrayList outHeaderList = new ArrayList(o.Length);
ArrayList faultHeaderList = new ArrayList();
SoapHeaderDirection unknownHeaderDirections = (SoapHeaderDirection)0;
for (int i = 0; i < o.Length; i++)
{
SoapHeaderAttribute att = (SoapHeaderAttribute)o[i];
MemberInfo[] mems = source.DeclaringType.GetMember(att.MemberName);
if (mems.Length == 0)
{
throw new InvalidOperationException("Member " + att.MemberName + " not found in class " + source.DeclaringType.FullName + ".");
}
HeaderInfo header = new HeaderInfo(mems[0], att);
allHeaderList.Add(header);
if (!header.Custom)
{
if ((header.Direction & SoapHeaderDirection.In) != 0)
{
inHeaderList.Add(header);
}
if ((header.Direction & SoapHeaderDirection.Out) != 0)
{
outHeaderList.Add(header);
}
if ((header.Direction & SoapHeaderDirection.Fault) != 0)
{
faultHeaderList.Add(header);
}
}
else
{
unknownHeaderDirections |= header.Direction;
}
}
Headers = (HeaderInfo[])allHeaderList.ToArray(typeof(HeaderInfo));
if (inHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.In) != 0)
{
InHeaders = (HeaderInfo[])inHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(InHeaders);
if (Use == SoapBindingUse.Literal)
{
InputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
InputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
requestHeadersSerializerId = parent.RegisterSerializer(InputHeaderMembersMapping);
}
if (outHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Out) != 0)
{
OutHeaders = (HeaderInfo[])outHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(OutHeaders);
if (Use == SoapBindingUse.Literal)
{
OutputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
OutputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
responseHeadersSerializerId = parent.RegisterSerializer(OutputHeaderMembersMapping);
}
if (faultHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Fault) != 0)
{
FaultHeaders = (HeaderInfo[])faultHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(FaultHeaders);
if (Use == SoapBindingUse.Literal)
{
FaultHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
FaultHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
faultHeadersSerializerId = parent.RegisterSerializer(FaultHeaderMembersMapping);
}
SoapExtensions = SoapExtension.GetMethodExtensions(source);
}
private static XmlMembersMapping ImportMembersMapping(XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, bool serviceDefaultIsEncoded, bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, string elementName, string elementNamespace, bool nsIsDefault, XmlReflectionMember[] members, bool validate, bool openModel, string key, bool writeAccess)
{
XmlMembersMapping mapping = null;
if (use == SoapBindingUse.Encoded)
{
string ns = ((!rpc && (paramStyle != SoapParameterStyle.Bare)) && nsIsDefault) ? GetEncodedNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
mapping = soapImporter.ImportMembersMapping(elementName, ns, members, rpc || (paramStyle != SoapParameterStyle.Bare), rpc, validate, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read);
}
else
{
string str2 = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
mapping = xmlImporter.ImportMembersMapping(elementName, str2, members, paramStyle != SoapParameterStyle.Bare, rpc, openModel, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read);
}
if (mapping != null)
{
mapping.SetKey(key);
}
return(mapping);
}
