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;
}
}
}
}
}
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;
}
protected virtual SoapBinding CreateSoapBinding(SoapBindingStyle style)
{
SoapBinding soapBinding = new SoapBinding();
soapBinding.Transport = SoapBinding.HttpTransport;
soapBinding.Style = style;
return(soapBinding);
}
protected virtual SoapOperationBinding CreateSoapOperationBinding(SoapBindingStyle style, string action)
{
SoapOperationBinding soapOperation = new SoapOperationBinding();
soapOperation.SoapAction = action;
soapOperation.Style = style;
return(soapOperation);
}
public SoapTypeStubInfo(LogicalTypeInfo logicalTypeInfo)
: base(logicalTypeInfo)
{
xmlImporter = new XmlReflectionImporter();
soapImporter = new SoapReflectionImporter();
if (typeof(SoapHttpClientProtocol).IsAssignableFrom(Type))
{
if (Bindings.Count == 0 || ((BindingInfo)Bindings[0]).WebServiceBindingAttribute == null)
{
throw new InvalidOperationException("WebServiceBindingAttribute is required on proxy class '" + Type + "'.");
}
if (Bindings.Count > 1)
{
throw new InvalidOperationException("Only one WebServiceBinding attribute may be specified on type '" + Type + "'.");
}
}
object [] o = Type.GetCustomAttributes(typeof(SoapDocumentServiceAttribute), false);
if (o.Length == 1)
{
SoapDocumentServiceAttribute a = (SoapDocumentServiceAttribute)o [0];
ParameterStyle = a.ParameterStyle;
SoapBindingStyle = SoapBindingStyle.Document;
}
else
{
o = Type.GetCustomAttributes(typeof(SoapRpcServiceAttribute), false);
if (o.Length == 1)
{
SoapRpcServiceAttribute srs = (SoapRpcServiceAttribute)o [0];
ParameterStyle = SoapParameterStyle.Wrapped;
SoapBindingStyle = SoapBindingStyle.Rpc;
}
else
{
ParameterStyle = SoapParameterStyle.Wrapped;
SoapBindingStyle = SoapBindingStyle.Document;
}
}
if (ParameterStyle == SoapParameterStyle.Default)
{
ParameterStyle = SoapParameterStyle.Wrapped;
}
xmlImporter.IncludeTypes(Type);
soapImporter.IncludeTypes(Type);
#if MONOTOUCH
SoapExtensions = new SoapExtensionRuntimeConfig [2][];
#else
SoapExtensions = SoapExtension.GetTypeExtensions(Type);
#endif
}
protected override SoapOperationBinding CreateSoapOperationBinding(SoapBindingStyle style, string action)
{
Soap12OperationBinding operation = new Soap12OperationBinding {
SoapAction = action,
Style = style,
Method = base.SoapMethod
};
this.DealWithAmbiguity(action, base.SoapMethod.requestElementName.ToString(), operation);
return operation;
}
protected override SoapOperationBinding CreateSoapOperationBinding(SoapBindingStyle style, string action)
{
Soap12OperationBinding operation = new Soap12OperationBinding {
SoapAction = action,
Style = style,
Method = base.SoapMethod
};
this.DealWithAmbiguity(action, base.SoapMethod.requestElementName.ToString(), operation);
return(operation);
}
protected override SoapOperationBinding CreateSoapOperationBinding(SoapBindingStyle style, string action)
{
Soap12OperationBinding soapOperation = new Soap12OperationBinding();
soapOperation.SoapAction = action;
soapOperation.Style = style;
soapOperation.Method = SoapMethod;
DealWithAmbiguity(action, SoapMethod.requestElementName.ToString(), soapOperation);
return(soapOperation);
}
internal static SoapBindingStyle GetStyle(Binding binding)
{
SoapBindingStyle style = SoapBindingStyle.Default;
if (binding != null)
{
SoapBinding binding2 = binding.Extensions.Find(typeof(SoapBinding)) as SoapBinding;
if (binding2 != null)
{
style = binding2.Style;
}
}
return(style);
}
internal static SoapBindingStyle GetStyle(OperationBinding operationBinding, SoapBindingStyle defaultBindingStyle)
{
SoapBindingStyle style = defaultBindingStyle;
if (operationBinding != null)
{
SoapOperationBinding binding = operationBinding.Extensions.Find(typeof(SoapOperationBinding)) as SoapOperationBinding;
if ((binding != null) && (binding.Style != SoapBindingStyle.Default))
{
style = binding.Style;
}
}
return(style);
}
public SoapBinding()
{
style = SoapBindingStyle.Document;
transport = String.Empty;
}
XmlMembersMapping ImportLiteralMessage(string messageName, MessagePart[] parts, SoapBodyBinding soapBodyBinding, SoapBindingStyle soapBindingStyle, bool wrapped) {
XmlMembersMapping membersMapping;
if (soapBindingStyle == SoapBindingStyle.Rpc) {
SoapSchemaMember[] schemaMembers = new SoapSchemaMember[parts.Length];
for (int i = 0; i < schemaMembers.Length; i++) {
MessagePart part = parts[i];
SoapSchemaMember schemaMember = new SoapSchemaMember();
schemaMember.MemberName = part.Name;
schemaMember.MemberType = part.Type;
schemaMembers[i] = schemaMember;
}
membersMapping = xmlImporter.ImportMembersMapping(messageName, soapBodyBinding.Namespace, schemaMembers);
}
else if (wrapped) {
membersMapping = xmlImporter.ImportMembersMapping(parts[0].Element);
}
else {
if (parts.Length == 1 && !parts[0].Type.IsEmpty) {
// special case for <any> at root
// we know this will work because we tried it earlier in CheckMessageStyles.
membersMapping = xmlImporter.ImportAnyType(parts[0].Type, parts[0].Name);
xmlMembers.Add(membersMapping);
return membersMapping;
}
XmlQualifiedName[] names = new XmlQualifiedName[parts.Length];
for (int i = 0; i < parts.Length; i++)
names[i] = parts[i].Element;
membersMapping = xmlImporter.ImportMembersMapping(names);
}
xmlMembers.Add(membersMapping);
return membersMapping;
}
public SoapOperationBinding ()
{
soapAction = String.Empty;
style = SoapBindingStyle.Default;
}
protected override SoapOperationBinding CreateSoapOperationBinding(SoapBindingStyle style, string action) {
Soap12OperationBinding soapOperation = new Soap12OperationBinding();
soapOperation.SoapAction = action;
soapOperation.Style = style;
soapOperation.Method = SoapMethod;
DealWithAmbiguity(action, SoapMethod.requestElementName.ToString(), soapOperation);
return soapOperation;
}
XmlMembersMapping ImportMembersMapping(Message msg, SoapBodyBinding sbb, SoapBindingStyle style, bool output, bool wrapped)
{
string elemName = Operation.Name;
if (output)
{
elemName += "Response";
}
if (wrapped)
{
// Wrapped parameter style
MessagePart part = msg.Parts[0];
if (sbb.Use == SoapBindingUse.Encoded)
{
SoapSchemaMember ssm = new SoapSchemaMember();
ssm.MemberName = part.Name;
ssm.MemberType = part.Type;
return(soapImporter.ImportMembersMapping(elemName, part.Type.Namespace, ssm));
}
else
{
return(xmlImporter.ImportMembersMapping(part.Element));
}
}
else
{
if (sbb.Use == SoapBindingUse.Encoded)
{
SoapSchemaMember[] mems = new SoapSchemaMember [msg.Parts.Count];
for (int n = 0; n < mems.Length; n++)
{
SoapSchemaMember mem = new SoapSchemaMember();
mem.MemberName = msg.Parts[n].Name;
mem.MemberType = msg.Parts[n].Type;
mems[n] = mem;
}
// Rpc messages always have a wrapping element
if (style == SoapBindingStyle.Rpc)
{
return(soapImporter.ImportMembersMapping(elemName, sbb.Namespace, mems, true));
}
else
{
return(soapImporter.ImportMembersMapping("", "", mems, false));
}
}
else
{
if (style == SoapBindingStyle.Rpc)
{
throw new InvalidOperationException("The combination of style=rpc with use=literal is not supported");
}
if (msg.Parts.Count == 1 && msg.Parts[0].Type != XmlQualifiedName.Empty)
{
return(xmlImporter.ImportAnyType(msg.Parts[0].Type, null));
}
else
{
XmlQualifiedName[] pnames = new XmlQualifiedName [msg.Parts.Count];
for (int n = 0; n < pnames.Length; n++)
{
pnames[n] = msg.Parts[n].Element;
}
return(xmlImporter.ImportMembersMapping(pnames));
}
}
}
}
protected virtual SoapOperationBinding CreateSoapOperationBinding(SoapBindingStyle style, string action) {
SoapOperationBinding soapOperation = new SoapOperationBinding();
soapOperation.SoapAction = action;
soapOperation.Style = style;
return soapOperation;
}
// returns false if we didn't like the message -- otherwise caller is safe to use body binding and binding style
bool CheckMessageStyles(string messageName, MessagePart[] parts, SoapBodyBinding soapBodyBinding, SoapBindingStyle soapBindingStyle, out bool hasWrapper) {
hasWrapper = false;
if (soapBodyBinding.Use == SoapBindingUse.Default) {
soapBodyBinding.Use = SoapBindingUse.Literal;
}
if (soapBodyBinding.Use == SoapBindingUse.Literal) {
if (soapBindingStyle == SoapBindingStyle.Rpc) {
foreach (MessagePart part in parts) {
if (!part.Element.IsEmpty) {
UnsupportedOperationBindingWarning(Res.GetString(Res.EachMessagePartInRpcUseLiteralMessageMustSpecify0));
return false;
}
}
return true;
}
if (parts.Length == 1 && !parts[0].Type.IsEmpty) {
// special top-level any case
if (!parts[0].Element.IsEmpty) {
UnsupportedOperationBindingWarning(Res.GetString(Res.SpecifyingATypeForUseLiteralMessagesIs0));
return false;
}
XmlMembersMapping membersMapping = xmlImporter.ImportAnyType(parts[0].Type, parts[0].Name);
if (membersMapping == null) {
UnsupportedOperationBindingWarning(Res.GetString(Res.SpecifyingATypeForUseLiteralMessagesIsAny, parts[0].Type.Name, parts[0].Type.Namespace));
return false;
}
return true;
}
else {
foreach (MessagePart part in parts) {
if (!part.Type.IsEmpty) {
UnsupportedOperationBindingWarning(Res.GetString(Res.SpecifyingATypeForUseLiteralMessagesIs0));
return false;
}
if (part.Element.IsEmpty) {
UnsupportedOperationBindingWarning(Res.GetString(Res.EachMessagePartInAUseLiteralMessageMustSpecify0));
return false;
}
}
}
}
else if (soapBodyBinding.Use == SoapBindingUse.Encoded) {
if (!IsSoapEncodingPresent(soapBodyBinding.Encoding)) {
UnsupportedOperationBindingWarning(Res.GetString(Res.TheEncodingIsNotSupported1, soapBodyBinding.Encoding));
return false;
}
foreach (MessagePart part in parts) {
if (!part.Element.IsEmpty) {
UnsupportedOperationBindingWarning(Res.GetString(Res.SpecifyingAnElementForUseEncodedMessageParts0));
return false;
}
if (part.Type.IsEmpty) {
UnsupportedOperationBindingWarning(Res.GetString(Res.EachMessagePartInAnUseEncodedMessageMustSpecify0));
return false;
}
}
}
if (soapBindingStyle == SoapBindingStyle.Rpc) {
return true;
}
else if (soapBindingStyle == SoapBindingStyle.Document) {
// NOTE, [....]. WSDL doesn't really let us figure out whether a document is
// in fact a struct containing parameters, so we apply a little heuristic here
// in order to produce the appropriate programming model.
hasWrapper = (parts.Length == 1 && string.Compare(parts[0].Name, "parameters", StringComparison.Ordinal) == 0);
return true;
}
return false;
}
//
// Constructor
//
public SoapMethodStubInfo(TypeStubInfo typeStub, LogicalMethodInfo source, object kind, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter)
: base(typeStub, source)
{
SoapTypeStubInfo parent = (SoapTypeStubInfo)typeStub;
XmlElementAttribute optional_ns = null;
if (kind == null)
{
Use = parent.LogicalType.BindingUse;
RequestName = "";
RequestNamespace = "";
ResponseName = "";
ResponseNamespace = "";
ParameterStyle = parent.ParameterStyle;
SoapBindingStyle = parent.SoapBindingStyle;
OneWay = false;
// disabled (see bug #332150)
//#if NET_2_0
// if (parent.Type != source.DeclaringType)
// Binding = source.DeclaringType.Name + parent.ProtocolName;
//#endif
}
else if (kind is SoapDocumentMethodAttribute)
{
SoapDocumentMethodAttribute dma = (SoapDocumentMethodAttribute)kind;
Use = dma.Use;
if (Use == SoapBindingUse.Default)
{
if (parent.SoapBindingStyle == SoapBindingStyle.Document)
{
Use = parent.LogicalType.BindingUse;
}
else
{
Use = SoapBindingUse.Literal;
}
}
Action = dma.Action;
Binding = dma.Binding;
RequestName = dma.RequestElementName;
RequestNamespace = dma.RequestNamespace;
ResponseName = dma.ResponseElementName;
ResponseNamespace = dma.ResponseNamespace;
ParameterStyle = dma.ParameterStyle;
if (ParameterStyle == SoapParameterStyle.Default)
{
ParameterStyle = parent.ParameterStyle;
}
OneWay = dma.OneWay;
SoapBindingStyle = SoapBindingStyle.Document;
}
else
{
SoapRpcMethodAttribute rma = (SoapRpcMethodAttribute)kind;
Use = SoapBindingUse.Encoded; // RPC always use encoded
Action = rma.Action;
if (Action != null && Action.Length == 0)
{
Action = null;
}
Binding = rma.Binding;
// When using RPC, MS.NET seems to ignore RequestElementName and
// MessageName, and it always uses the method name
RequestName = source.Name;
ResponseName = source.Name + "Response";
// RequestName = rma.RequestElementName;
// ResponseName = rma.ResponseElementName;
RequestNamespace = rma.RequestNamespace;
ResponseNamespace = rma.ResponseNamespace;
ParameterStyle = SoapParameterStyle.Wrapped;
OneWay = rma.OneWay;
SoapBindingStyle = SoapBindingStyle.Rpc;
// For RPC calls, make all arguments be part of the empty namespace
optional_ns = new XmlElementAttribute();
optional_ns.Namespace = "";
}
if (OneWay)
{
if (source.ReturnType != typeof(void))
{
throw new Exception("OneWay methods should not have a return value.");
}
if (source.OutParameters.Length != 0)
{
throw new Exception("OneWay methods should not have out/ref parameters.");
}
}
BindingInfo binfo = parent.GetBinding(Binding);
if (binfo == null)
{
throw new InvalidOperationException("Type '" + parent.Type + "' is missing WebServiceBinding attribute that defines a binding named '" + Binding + "'.");
}
string serviceNamespace = binfo.Namespace;
if (RequestNamespace == "")
{
RequestNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use);
}
if (ResponseNamespace == "")
{
ResponseNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use);
}
if (RequestName == "")
{
RequestName = Name;
}
if (ResponseName == "")
{
ResponseName = Name + "Response";
}
if (Action == null)
{
Action = serviceNamespace.EndsWith("/") ? (serviceNamespace + Name) : (serviceNamespace + "/" + Name);
}
bool hasWrappingElem = (ParameterStyle == SoapParameterStyle.Wrapped);
bool writeAccessors = (SoapBindingStyle == SoapBindingStyle.Rpc);
XmlReflectionMember [] in_members = BuildRequestReflectionMembers(optional_ns);
XmlReflectionMember [] out_members = BuildResponseReflectionMembers(optional_ns);
if (Use == SoapBindingUse.Literal)
{
xmlImporter.IncludeTypes(source.CustomAttributeProvider);
InputMembersMapping = xmlImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem);
OutputMembersMapping = xmlImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem);
}
else
{
soapImporter.IncludeTypes(source.CustomAttributeProvider);
InputMembersMapping = soapImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem, writeAccessors);
OutputMembersMapping = soapImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem, writeAccessors);
}
requestSerializerId = parent.RegisterSerializer(InputMembersMapping);
responseSerializerId = parent.RegisterSerializer(OutputMembersMapping);
object[] o = source.GetCustomAttributes(typeof(SoapHeaderAttribute));
ArrayList allHeaderList = new ArrayList(o.Length);
ArrayList inHeaderList = new ArrayList(o.Length);
ArrayList outHeaderList = new ArrayList(o.Length);
ArrayList faultHeaderList = new ArrayList();
SoapHeaderDirection unknownHeaderDirections = (SoapHeaderDirection)0;
for (int i = 0; i < o.Length; i++)
{
SoapHeaderAttribute att = (SoapHeaderAttribute)o[i];
MemberInfo[] mems = source.DeclaringType.GetMember(att.MemberName);
if (mems.Length == 0)
{
throw new InvalidOperationException("Member " + att.MemberName + " not found in class " + source.DeclaringType.FullName + ".");
}
HeaderInfo header = new HeaderInfo(mems[0], att);
allHeaderList.Add(header);
if (!header.Custom)
{
if ((header.Direction & SoapHeaderDirection.In) != 0)
{
inHeaderList.Add(header);
}
if ((header.Direction & SoapHeaderDirection.Out) != 0)
{
outHeaderList.Add(header);
}
if ((header.Direction & SoapHeaderDirection.Fault) != 0)
{
faultHeaderList.Add(header);
}
}
else
{
unknownHeaderDirections |= header.Direction;
}
}
Headers = (HeaderInfo[])allHeaderList.ToArray(typeof(HeaderInfo));
if (inHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.In) != 0)
{
InHeaders = (HeaderInfo[])inHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(InHeaders);
if (Use == SoapBindingUse.Literal)
{
InputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
InputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
requestHeadersSerializerId = parent.RegisterSerializer(InputHeaderMembersMapping);
}
if (outHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Out) != 0)
{
OutHeaders = (HeaderInfo[])outHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(OutHeaders);
if (Use == SoapBindingUse.Literal)
{
OutputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
OutputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
responseHeadersSerializerId = parent.RegisterSerializer(OutputHeaderMembersMapping);
}
if (faultHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Fault) != 0)
{
FaultHeaders = (HeaderInfo[])faultHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(FaultHeaders);
if (Use == SoapBindingUse.Literal)
{
FaultHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
FaultHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
faultHeadersSerializerId = parent.RegisterSerializer(FaultHeaderMembersMapping);
}
SoapExtensions = SoapExtension.GetMethodExtensions(source);
}
public 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);
}
LiteralType GetLiteralBindingType(Binding b)
{
SoapBinding sb = (SoapBinding)b.Extensions.Find(typeof(SoapBinding));
SoapBindingStyle style = (sb != null) ? sb.Style : SoapBindingStyle.Document;
if (style == SoapBindingStyle.Default)
{
style = SoapBindingStyle.Document;
}
foreach (OperationBinding ob in b.Operations)
{
SoapOperationBinding sob = (SoapOperationBinding)ob.Extensions.Find(typeof(SoapOperationBinding));
if (sob.Style != SoapBindingStyle.Default && sob.Style != style)
{
return(LiteralType.Inconsistent);
}
if (ob.Input != null)
{
SoapBodyBinding sbb = (SoapBodyBinding)ob.Input.Extensions.Find(typeof(SoapBodyBinding));
if (sbb != null && sbb.Use != SoapBindingUse.Literal)
{
return(LiteralType.NotLiteral);
}
SoapFaultBinding sfb = (SoapFaultBinding)ob.Input.Extensions.Find(typeof(SoapFaultBinding));
if (sfb != null && sfb.Use != SoapBindingUse.Literal)
{
return(LiteralType.NotLiteral);
}
SoapHeaderBinding shb = (SoapHeaderBinding)ob.Input.Extensions.Find(typeof(SoapHeaderBinding));
if (shb != null && shb.Use != SoapBindingUse.Literal)
{
return(LiteralType.NotLiteral);
}
SoapHeaderFaultBinding shfb = (SoapHeaderFaultBinding)ob.Input.Extensions.Find(typeof(SoapHeaderFaultBinding));
if (shfb != null && shfb.Use != SoapBindingUse.Literal)
{
return(LiteralType.NotLiteral);
}
}
if (ob.Output != null)
{
SoapBodyBinding sbb = (SoapBodyBinding)ob.Output.Extensions.Find(typeof(SoapBodyBinding));
if (sbb != null && sbb.Use != SoapBindingUse.Literal)
{
return(LiteralType.NotLiteral);
}
SoapFaultBinding sfb = (SoapFaultBinding)ob.Input.Extensions.Find(typeof(SoapFaultBinding));
if (sfb != null && sfb.Use != SoapBindingUse.Literal)
{
return(LiteralType.NotLiteral);
}
SoapHeaderBinding shb = (SoapHeaderBinding)ob.Input.Extensions.Find(typeof(SoapHeaderBinding));
if (shb != null && shb.Use != SoapBindingUse.Literal)
{
return(LiteralType.NotLiteral);
}
SoapHeaderFaultBinding shfb = (SoapHeaderFaultBinding)ob.Input.Extensions.Find(typeof(SoapHeaderFaultBinding));
if (shfb != null && shfb.Use != SoapBindingUse.Literal)
{
return(LiteralType.NotLiteral);
}
}
}
if (style == SoapBindingStyle.Document)
{
return(LiteralType.Document);
}
else
{
return(LiteralType.Rpc);
}
}
public SoapBinding ()
{
style = SoapBindingStyle.Document;
transport = String.Empty;
}
internal static bool AnalyzeBinding(Binding binding, ServiceDescription description, ServiceDescriptionCollection descriptions, BasicProfileViolationCollection violations)
{
bool flag = false;
bool flag2 = false;
SoapBinding binding2 = (SoapBinding)binding.Extensions.Find(typeof(SoapBinding));
if ((binding2 == null) || (binding2.GetType() != typeof(SoapBinding)))
{
return(false);
}
SoapBindingStyle style = (binding2.Style == SoapBindingStyle.Default) ? SoapBindingStyle.Document : binding2.Style;
if (binding2.Transport.Length == 0)
{
violations.Add("R2701", System.Web.Services.Res.GetString("BindingMissingAttribute", new object[] { binding.Name, description.TargetNamespace, "transport" }));
}
else if (binding2.Transport != "http://schemas.xmlsoap.org/soap/http")
{
violations.Add("R2702", System.Web.Services.Res.GetString("BindingInvalidAttribute", new object[] { binding.Name, description.TargetNamespace, "transport", binding2.Transport }));
}
PortType portType = descriptions.GetPortType(binding.Type);
Hashtable hashtable = new Hashtable();
if (portType != null)
{
foreach (Operation operation in portType.Operations)
{
if (operation.Messages.Flow == OperationFlow.Notification)
{
violations.Add("R2303", System.Web.Services.Res.GetString("OperationFlowNotification", new object[] { operation.Name, binding.Type.Namespace, binding.Type.Namespace }));
}
if (operation.Messages.Flow == OperationFlow.SolicitResponse)
{
violations.Add("R2303", System.Web.Services.Res.GetString("OperationFlowSolicitResponse", new object[] { operation.Name, binding.Type.Namespace, binding.Type.Namespace }));
}
if (hashtable[operation.Name] != null)
{
violations.Add("R2304", System.Web.Services.Res.GetString("Operation", new object[] { operation.Name, binding.Type.Name, binding.Type.Namespace }));
}
else
{
OperationBinding binding3 = null;
foreach (OperationBinding binding4 in binding.Operations)
{
if (operation.IsBoundBy(binding4))
{
if (binding3 != null)
{
violations.Add("R2304", System.Web.Services.Res.GetString("OperationBinding", new object[] { binding3.Name, binding3.Parent.Name, description.TargetNamespace }));
}
binding3 = binding4;
}
}
if (binding3 == null)
{
violations.Add("R2718", System.Web.Services.Res.GetString("OperationMissingBinding", new object[] { operation.Name, binding.Type.Name, binding.Type.Namespace }));
}
else
{
hashtable.Add(operation.Name, operation);
}
}
}
}
Hashtable wireSignatures = new Hashtable();
SoapBindingStyle style2 = SoapBindingStyle.Default;
foreach (OperationBinding binding5 in binding.Operations)
{
SoapBindingStyle style3 = style;
string name = binding5.Name;
if (name != null)
{
if (hashtable[name] == null)
{
violations.Add("R2718", System.Web.Services.Res.GetString("PortTypeOperationMissing", new object[] { binding5.Name, binding.Name, description.TargetNamespace, binding.Type.Name, binding.Type.Namespace }));
}
Operation operation2 = FindOperation(portType.Operations, binding5);
SoapOperationBinding binding6 = (SoapOperationBinding)binding5.Extensions.Find(typeof(SoapOperationBinding));
if (binding6 != null)
{
if (style2 == SoapBindingStyle.Default)
{
style2 = binding6.Style;
}
flag |= style2 != binding6.Style;
style3 = (binding6.Style != SoapBindingStyle.Default) ? binding6.Style : style;
}
if (binding5.Input != null)
{
SoapBodyBinding binding7 = FindSoapBodyBinding(true, binding5.Input.Extensions, violations, style3 == SoapBindingStyle.Document, binding5.Name, binding.Name, description.TargetNamespace);
if ((binding7 != null) && (binding7.Use != SoapBindingUse.Encoded))
{
Message message = (operation2 == null) ? null : ((operation2.Messages.Input == null) ? null : descriptions.GetMessage(operation2.Messages.Input.Message));
if (style3 == SoapBindingStyle.Rpc)
{
CheckMessageParts(message, binding7.Parts, false, binding5.Name, binding.Name, description.TargetNamespace, wireSignatures, violations);
}
else
{
flag2 = flag2 || ((binding7.Parts != null) && (binding7.Parts.Length > 1));
int num = (binding7.Parts == null) ? 0 : binding7.Parts.Length;
CheckMessageParts(message, binding7.Parts, true, binding5.Name, binding.Name, description.TargetNamespace, wireSignatures, violations);
if (((num == 0) && (message != null)) && (message.Parts.Count > 1))
{
violations.Add("R2210", System.Web.Services.Res.GetString("OperationBinding", new object[] { binding5.Name, binding.Name, description.TargetNamespace }));
}
}
}
}
if (binding5.Output != null)
{
SoapBodyBinding binding8 = FindSoapBodyBinding(false, binding5.Output.Extensions, violations, style3 == SoapBindingStyle.Document, binding5.Name, binding.Name, description.TargetNamespace);
if ((binding8 != null) && (binding8.Use != SoapBindingUse.Encoded))
{
Message message2 = (operation2 == null) ? null : ((operation2.Messages.Output == null) ? null : descriptions.GetMessage(operation2.Messages.Output.Message));
if (style3 == SoapBindingStyle.Rpc)
{
CheckMessageParts(message2, binding8.Parts, false, binding5.Name, binding.Name, description.TargetNamespace, null, violations);
}
else
{
flag2 = flag2 || ((binding8.Parts != null) && (binding8.Parts.Length > 1));
int num2 = (binding8.Parts == null) ? 0 : binding8.Parts.Length;
CheckMessageParts(message2, binding8.Parts, true, binding5.Name, binding.Name, description.TargetNamespace, null, violations);
if (((num2 == 0) && (message2 != null)) && (message2.Parts.Count > 1))
{
violations.Add("R2210", System.Web.Services.Res.GetString("OperationBinding", new object[] { binding5.Name, binding.Name, description.TargetNamespace }));
}
}
}
}
foreach (FaultBinding binding9 in binding5.Faults)
{
foreach (ServiceDescriptionFormatExtension extension in binding9.Extensions)
{
if (extension is SoapFaultBinding)
{
SoapFaultBinding item = (SoapFaultBinding)extension;
if (item.Use == SoapBindingUse.Encoded)
{
violations.Add("R2706", MessageString(item, binding5.Name, binding.Name, description.TargetNamespace, false, null));
}
else
{
if ((item.Name == null) || (item.Name.Length == 0))
{
violations.Add("R2721", System.Web.Services.Res.GetString("FaultBinding", new object[] { binding9.Name, binding5.Name, binding.Name, description.TargetNamespace }));
}
else if (item.Name != binding9.Name)
{
violations.Add("R2754", System.Web.Services.Res.GetString("FaultBinding", new object[] { binding9.Name, binding5.Name, binding.Name, description.TargetNamespace }));
}
if ((item.Namespace != null) && (item.Namespace.Length > 0))
{
violations.Add((style3 == SoapBindingStyle.Document) ? "R2716" : "R2726", MessageString(item, binding5.Name, binding.Name, description.TargetNamespace, false, null));
}
}
}
}
}
if (hashtable[binding5.Name] == null)
{
violations.Add("R2718", System.Web.Services.Res.GetString("PortTypeOperationMissing", new object[] { binding5.Name, binding.Name, description.TargetNamespace, binding.Type.Name, binding.Type.Namespace }));
}
}
}
if (flag2)
{
violations.Add("R2201", System.Web.Services.Res.GetString("BindingMultipleParts", new object[] { binding.Name, description.TargetNamespace, "parts" }));
}
if (flag)
{
violations.Add("R2705", System.Web.Services.Res.GetString("Binding", new object[] { binding.Name, description.TargetNamespace }));
}
return(true);
}
protected virtual SoapOperationBinding CreateSoapOperationBinding(SoapBindingStyle style, string action)
{
return new SoapOperationBinding { SoapAction = action, Style = style };
}
protected virtual SoapBinding CreateSoapBinding(SoapBindingStyle style)
{
return new SoapBinding { Transport = "http://schemas.xmlsoap.org/soap/http", Style = style };
}
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;
}
protected virtual SoapOperationBinding CreateSoapOperationBinding(SoapBindingStyle style, string action)
{
return(new SoapOperationBinding {
SoapAction = action, Style = style
});
}
//
// 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);
}
void WriteBody(XmlTextWriter xtw, Operation oper, OperationMessage opm, SoapBodyBinding sbb, SoapBindingStyle style)
{
Message msg = descriptions.GetMessage(opm.Message);
if (msg.Parts.Count > 0 && msg.Parts[0].Name == "parameters") {
MessagePart part = msg.Parts[0];
if (part.Element == XmlQualifiedName.Empty)
WriteTypeSample(xtw, part.Type);
else
WriteRootElementSample(xtw, part.Element);
}
else {
string elemName = oper.Name;
string ns = "";
if (opm is OperationOutput) elemName += "Response";
if (style == SoapBindingStyle.Rpc) {
xtw.WriteStartElement(elemName, sbb.Namespace);
ns = sbb.Namespace;
}
foreach (MessagePart part in msg.Parts) {
if (part.Element == XmlQualifiedName.Empty) {
XmlSchemaElement elem = new XmlSchemaElement();
elem.SchemaTypeName = part.Type;
elem.Name = part.Name;
WriteElementSample(xtw, ns, elem);
}
else
WriteRootElementSample(xtw, part.Element);
}
if (style == SoapBindingStyle.Rpc)
xtw.WriteEndElement();
}
WriteQueuedTypeSamples(xtw);
}
XmlMembersMapping ImportMembersMapping (Message msg, SoapBodyBinding sbb, SoapBindingStyle style, bool output)
{
string elemName = Operation.Name;
if (output) elemName += "Response";
if (msg.Parts.Count == 1 && msg.Parts[0].Name == "parameters")
{
// Wrapped parameter style
MessagePart part = msg.Parts[0];
if (sbb.Use == SoapBindingUse.Encoded)
{
SoapSchemaMember ssm = new SoapSchemaMember ();
ssm.MemberName = part.Name;
ssm.MemberType = part.Type;
return soapImporter.ImportMembersMapping (elemName, part.Type.Namespace, ssm);
}
else
return xmlImporter.ImportMembersMapping (part.Element);
}
else
{
if (sbb.Use == SoapBindingUse.Encoded)
{
SoapSchemaMember[] mems = new SoapSchemaMember [msg.Parts.Count];
for (int n=0; n<mems.Length; n++)
{
SoapSchemaMember mem = new SoapSchemaMember();
mem.MemberName = msg.Parts[n].Name;
mem.MemberType = msg.Parts[n].Type;
mems[n] = mem;
}
// Rpc messages always have a wrapping element
if (style == SoapBindingStyle.Rpc)
return soapImporter.ImportMembersMapping (elemName, sbb.Namespace, mems, true);
else
return soapImporter.ImportMembersMapping ("", "", mems, false);
}
else
{
if (style == SoapBindingStyle.Rpc)
throw new InvalidOperationException ("The combination of style=rpc with use=literal is not supported");
if (msg.Parts.Count == 1 && msg.Parts[0].Type != XmlQualifiedName.Empty)
return xmlImporter.ImportAnyType (msg.Parts[0].Type, null);
else
{
XmlQualifiedName[] pnames = new XmlQualifiedName [msg.Parts.Count];
for (int n=0; n<pnames.Length; n++)
pnames[n] = msg.Parts[n].Element;
return xmlImporter.ImportMembersMapping (pnames);
}
}
}
}
private bool CheckMessageStyles(string messageName, MessagePart[] parts, SoapBodyBinding soapBodyBinding, SoapBindingStyle soapBindingStyle, out bool hasWrapper)
{
hasWrapper = false;
if (soapBodyBinding.Use == SoapBindingUse.Default)
{
soapBodyBinding.Use = SoapBindingUse.Literal;
}
if (soapBodyBinding.Use == SoapBindingUse.Literal)
{
if (soapBindingStyle == SoapBindingStyle.Rpc)
{
foreach (MessagePart part in parts)
{
if (!part.Element.IsEmpty)
{
base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("EachMessagePartInRpcUseLiteralMessageMustSpecify0"));
return false;
}
}
return true;
}
if ((parts.Length == 1) && !parts[0].Type.IsEmpty)
{
if (!parts[0].Element.IsEmpty)
{
base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("SpecifyingATypeForUseLiteralMessagesIs0"));
return false;
}
if (this.xmlImporter.ImportAnyType(parts[0].Type, parts[0].Name) == null)
{
base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("SpecifyingATypeForUseLiteralMessagesIsAny", new object[] { parts[0].Type.Name, parts[0].Type.Namespace }));
return false;
}
return true;
}
foreach (MessagePart part2 in parts)
{
if (!part2.Type.IsEmpty)
{
base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("SpecifyingATypeForUseLiteralMessagesIs0"));
return false;
}
if (part2.Element.IsEmpty)
{
base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("EachMessagePartInAUseLiteralMessageMustSpecify0"));
return false;
}
}
}
else if (soapBodyBinding.Use == SoapBindingUse.Encoded)
{
if (!this.IsSoapEncodingPresent(soapBodyBinding.Encoding))
{
base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("TheEncodingIsNotSupported1", new object[] { soapBodyBinding.Encoding }));
return false;
}
foreach (MessagePart part3 in parts)
{
if (!part3.Element.IsEmpty)
{
base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("SpecifyingAnElementForUseEncodedMessageParts0"));
return false;
}
if (part3.Type.IsEmpty)
{
base.UnsupportedOperationBindingWarning(System.Web.Services.Res.GetString("EachMessagePartInAnUseEncodedMessageMustSpecify0"));
return false;
}
}
}
if (soapBindingStyle == SoapBindingStyle.Rpc)
{
return true;
}
if (soapBindingStyle == SoapBindingStyle.Document)
{
hasWrapper = (parts.Length == 1) && (string.Compare(parts[0].Name, "parameters", StringComparison.Ordinal) == 0);
return true;
}
return false;
}
private string Write82_SoapBindingStyle(SoapBindingStyle v)
{
switch (v)
{
case SoapBindingStyle.Document:
return "document";
case SoapBindingStyle.Rpc:
return "rpc";
}
long num = (long) v;
throw base.CreateInvalidEnumValueException(num.ToString(CultureInfo.InvariantCulture), "System.Web.Services.Description.SoapBindingStyle");
}
protected virtual SoapBinding CreateSoapBinding(SoapBindingStyle style)
{
return(new SoapBinding {
Transport = "http://schemas.xmlsoap.org/soap/http", Style = style
});
}
private XmlMembersMapping ImportLiteralMessage(string messageName, MessagePart[] parts, SoapBodyBinding soapBodyBinding, SoapBindingStyle soapBindingStyle, bool wrapped)
{
XmlMembersMapping mapping;
if (soapBindingStyle == SoapBindingStyle.Rpc)
{
SoapSchemaMember[] members = new SoapSchemaMember[parts.Length];
for (int i = 0; i < members.Length; i++)
{
MessagePart part = parts[i];
members[i] = new SoapSchemaMember { MemberName = part.Name, MemberType = part.Type };
}
mapping = this.xmlImporter.ImportMembersMapping(messageName, soapBodyBinding.Namespace, members);
}
else if (wrapped)
{
mapping = this.xmlImporter.ImportMembersMapping(parts[0].Element);
}
else
{
if ((parts.Length == 1) && !parts[0].Type.IsEmpty)
{
mapping = this.xmlImporter.ImportAnyType(parts[0].Type, parts[0].Name);
this.xmlMembers.Add(mapping);
return mapping;
}
XmlQualifiedName[] names = new XmlQualifiedName[parts.Length];
for (int j = 0; j < parts.Length; j++)
{
names[j] = parts[j].Element;
}
mapping = this.xmlImporter.ImportMembersMapping(names);
}
this.xmlMembers.Add(mapping);
return mapping;
}
/// <summary>
/// Search and returns the type mapping between method parameters/return value
/// and the element parts of a literal-use SOAP message.
/// </summary>
private XmlMembersMapping GetMembersMapping(string messageName, MessagePartCollection messageParts, SoapBodyBinding soapBodyBinding, SoapBindingStyle soapBindingStyle)
{
#if NET_2_0
if (soapBindingStyle == SoapBindingStyle.Rpc)
{
SoapSchemaMember[] soapSchemaMembers = new SoapSchemaMember[messageParts.Count];
for (int i = 0; i < messageParts.Count; i++)
{
SoapSchemaMember ssm = new SoapSchemaMember();
ssm.MemberName = messageParts[i].Name;
ssm.MemberType = messageParts[i].Type;
soapSchemaMembers[i] = ssm;
}
return(this.schemaImporter.ImportMembersMapping(messageName, soapBodyBinding.Namespace, soapSchemaMembers));
}
else
{
return(this.schemaImporter.ImportMembersMapping(messageParts[0].Element));
}
#else
return(this.schemaImporter.ImportMembersMapping(messageParts[0].Element));
#endif
}
private XmlMembersMapping ImportMessage(string messageName, MessagePart[] parts, SoapBodyBinding soapBodyBinding, SoapBindingStyle soapBindingStyle, bool wrapped)
{
if (soapBodyBinding.Use == SoapBindingUse.Encoded)
{
return this.ImportEncodedMessage(messageName, parts, soapBodyBinding, wrapped);
}
return this.ImportLiteralMessage(messageName, parts, soapBodyBinding, soapBindingStyle, wrapped);
}
public SoapTypeStubInfo (LogicalTypeInfo logicalTypeInfo)
: base (logicalTypeInfo)
{
xmlImporter = new XmlReflectionImporter ();
soapImporter = new SoapReflectionImporter ();
if (typeof (SoapHttpClientProtocol).IsAssignableFrom (Type))
{
if (Bindings.Count == 0 || ((BindingInfo)Bindings[0]).WebServiceBindingAttribute == null)
throw new InvalidOperationException ("WebServiceBindingAttribute is required on proxy class '" + Type + "'.");
if (Bindings.Count > 1)
throw new InvalidOperationException ("Only one WebServiceBinding attribute may be specified on type '" + Type + "'.");
}
object [] o = Type.GetCustomAttributes (typeof (SoapDocumentServiceAttribute), false);
if (o.Length == 1){
SoapDocumentServiceAttribute a = (SoapDocumentServiceAttribute) o [0];
ParameterStyle = a.ParameterStyle;
SoapBindingStyle = SoapBindingStyle.Document;
} else {
o = Type.GetCustomAttributes (typeof (SoapRpcServiceAttribute), false);
if (o.Length == 1){
ParameterStyle = SoapParameterStyle.Wrapped;
SoapBindingStyle = SoapBindingStyle.Rpc;
} else {
ParameterStyle = SoapParameterStyle.Wrapped;
SoapBindingStyle = SoapBindingStyle.Document;
}
}
if (ParameterStyle == SoapParameterStyle.Default) ParameterStyle = SoapParameterStyle.Wrapped;
xmlImporter.IncludeTypes (Type);
soapImporter.IncludeTypes (Type);
#if MOBILE || XAMMAC_4_5
SoapExtensions = new SoapExtensionRuntimeConfig [2][];
#else
SoapExtensions = SoapExtension.GetTypeExtensions (Type);
#endif
}
public SoapOperationBinding()
{
soapAction = String.Empty;
style = SoapBindingStyle.Default;
}
protected virtual SoapBinding CreateSoapBinding(SoapBindingStyle style) {
SoapBinding soapBinding = new SoapBinding();
soapBinding.Transport = SoapBinding.HttpTransport;
soapBinding.Style = style;
return soapBinding;
}
/// <summary>
/// Search and returns the type mapping between method parameters/return value
/// and the element parts of a literal-use SOAP message.
/// </summary>
private XmlMembersMapping GetMembersMapping(string messageName, MessagePartCollection messageParts, SoapBodyBinding soapBodyBinding, SoapBindingStyle soapBindingStyle)
{
if (soapBindingStyle == SoapBindingStyle.Rpc)
{
SoapSchemaMember[] soapSchemaMembers = new SoapSchemaMember[messageParts.Count];
for (int i = 0; i < messageParts.Count; i++)
{
SoapSchemaMember ssm = new SoapSchemaMember();
ssm.MemberName = messageParts[i].Name;
ssm.MemberType = messageParts[i].Type;
soapSchemaMembers[i] = ssm;
}
return this.schemaImporter.ImportMembersMapping(messageName, soapBodyBinding.Namespace, soapSchemaMembers);
}
else
{
return this.schemaImporter.ImportMembersMapping(messageParts[0].Element);
}
}
protected override CodeMemberMethod GenerateMethod()
{
try
{
SoapOperationBinding soapOper = OperationBinding.Extensions.Find(typeof(SoapOperationBinding)) as SoapOperationBinding;
if (soapOper == null)
{
throw new InvalidOperationException("Soap operation binding not found");
}
SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style;
SoapBodyBinding isbb = null;
XmlMembersMapping inputMembers = null;
bool isWrapped = CheckIsWrapped();
isbb = OperationBinding.Input.Extensions.Find(typeof(SoapBodyBinding)) as SoapBodyBinding;
if (isbb == null)
{
throw new InvalidOperationException("Soap body binding not found");
}
inputMembers = ImportMembersMapping(InputMessage, isbb, style, false, isWrapped);
if (inputMembers == null)
{
throw new InvalidOperationException("Input message not declared");
}
// If OperationBinding.Output is null, it is an OneWay operation
SoapBodyBinding osbb = null;
XmlMembersMapping outputMembers = null;
if (OperationBinding.Output != null)
{
osbb = OperationBinding.Output.Extensions.Find(typeof(SoapBodyBinding)) as SoapBodyBinding;
if (osbb == null)
{
throw new InvalidOperationException("Soap body binding not found");
}
outputMembers = ImportMembersMapping(OutputMessage, osbb, style, true, isWrapped);
if (outputMembers == null)
{
throw new InvalidOperationException("Output message not declared");
}
}
CodeMemberMethod met = GenerateMethod(memberIds, soapOper, isbb, inputMembers, outputMembers);
if (isbb.Use == SoapBindingUse.Literal)
{
xmlExporter.ExportMembersMapping(inputMembers);
}
else
{
soapExporter.ExportMembersMapping(inputMembers);
}
if (osbb != null)
{
if (osbb.Use == SoapBindingUse.Literal)
{
xmlExporter.ExportMembersMapping(outputMembers);
}
else
{
soapExporter.ExportMembersMapping(outputMembers);
}
}
foreach (SoapExtensionImporter eximporter in extensionImporters)
{
eximporter.ImportContext = this;
eximporter.ImportMethod(met.CustomAttributes);
}
return(met);
}
catch (InvalidOperationException ex)
{
UnsupportedOperationBindingWarning(ex.Message);
return(null);
}
}
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());
}
CodeMemberMethod GenerateMethod(CodeIdentifiers memberIds, SoapOperationBinding soapOper, SoapBodyBinding bodyBinding, XmlMembersMapping inputMembers, XmlMembersMapping outputMembers)
{
CodeIdentifiers pids = new CodeIdentifiers();
CodeMemberMethod method = new CodeMemberMethod();
CodeMemberMethod methodBegin = new CodeMemberMethod();
CodeMemberMethod methodEnd = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodBegin.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodEnd.Attributes = MemberAttributes.Public | MemberAttributes.Final;
SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style;
// Find unique names for temporary variables
for (int n = 0; n < inputMembers.Count; n++)
{
pids.AddUnique(inputMembers[n].MemberName, inputMembers[n]);
}
if (outputMembers != null)
{
for (int n = 0; n < outputMembers.Count; n++)
{
pids.AddUnique(outputMembers[n].MemberName, outputMembers[n]);
}
}
string varAsyncResult = pids.AddUnique("asyncResult", "asyncResult");
string varResults = pids.AddUnique("results", "results");
string varCallback = pids.AddUnique("callback", "callback");
string varAsyncState = pids.AddUnique("asyncState", "asyncState");
string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name), method);
method.Name = CodeIdentifier.MakeValid(Operation.Name);
if (method.Name == ClassName)
{
method.Name += "1";
}
methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + method.Name), method);
methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + method.Name), method);
method.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), varAsyncResult));
CodeExpression[] paramArray = new CodeExpression [inputMembers.Count];
CodeParameterDeclarationExpression[] outParams = new CodeParameterDeclarationExpression [outputMembers != null ? outputMembers.Count : 0];
for (int n = 0; n < inputMembers.Count; n++)
{
CodeParameterDeclarationExpression param = GenerateParameter(inputMembers[n], FieldDirection.In);
method.Parameters.Add(param);
GenerateMemberAttributes(inputMembers, inputMembers[n], bodyBinding.Use, param);
methodBegin.Parameters.Add(GenerateParameter(inputMembers[n], FieldDirection.In));
paramArray [n] = new CodeVariableReferenceExpression(param.Name);
}
if (outputMembers != null)
{
bool hasReturn = false;
for (int n = 0; n < outputMembers.Count; n++)
{
CodeParameterDeclarationExpression cpd = GenerateParameter(outputMembers[n], FieldDirection.Out);
outParams [n] = cpd;
bool found = false;
foreach (CodeParameterDeclarationExpression ip in method.Parameters)
{
if (ip.Name == cpd.Name && ip.Type.BaseType == cpd.Type.BaseType)
{
ip.Direction = FieldDirection.Ref;
methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
found = true;
break;
}
}
if (found)
{
continue;
}
if (!hasReturn)
{
hasReturn = true;
method.ReturnType = cpd.Type;
methodEnd.ReturnType = cpd.Type;
GenerateReturnAttributes(outputMembers, outputMembers[n], bodyBinding.Use, method);
outParams [n] = null;
continue;
}
method.Parameters.Add(cpd);
GenerateMemberAttributes(outputMembers, outputMembers[n], bodyBinding.Use, cpd);
methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
}
}
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), varCallback));
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), varAsyncState));
methodBegin.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
// Array of input parameters
CodeArrayCreateExpression methodParams;
if (paramArray.Length > 0)
{
methodParams = new CodeArrayCreateExpression(typeof(object), paramArray);
}
else
{
methodParams = new CodeArrayCreateExpression(typeof(object), 0);
}
// Assignment of output parameters
CodeStatementCollection outAssign = new CodeStatementCollection();
CodeVariableReferenceExpression arrVar = new CodeVariableReferenceExpression(varResults);
for (int n = 0; n < outParams.Length; n++)
{
CodeExpression index = new CodePrimitiveExpression(n);
if (outParams[n] == null)
{
CodeExpression res = new CodeCastExpression(method.ReturnType, new CodeArrayIndexerExpression(arrVar, index));
outAssign.Add(new CodeMethodReturnStatement(res));
}
else
{
CodeExpression res = new CodeCastExpression(outParams[n].Type, new CodeArrayIndexerExpression(arrVar, index));
CodeExpression var = new CodeVariableReferenceExpression(outParams[n].Name);
outAssign.Insert(0, new CodeAssignStatement(var, res));
}
}
if (Style == ServiceDescriptionImportStyle.Client)
{
// Invoke call
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression varMsgName = new CodePrimitiveExpression(messageName);
CodeMethodInvokeExpression inv;
CodeVariableDeclarationStatement dec;
inv = new CodeMethodInvokeExpression(ethis, "Invoke", varMsgName, methodParams);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
method.Statements.Add(dec);
method.Statements.AddRange(outAssign);
}
else
{
method.Statements.Add(inv);
}
// Begin Invoke Call
CodeExpression expCallb = new CodeVariableReferenceExpression(varCallback);
CodeExpression expAsyncs = new CodeVariableReferenceExpression(varAsyncState);
inv = new CodeMethodInvokeExpression(ethis, "BeginInvoke", varMsgName, methodParams, expCallb, expAsyncs);
methodBegin.Statements.Add(new CodeMethodReturnStatement(inv));
// End Invoke call
CodeExpression varAsyncr = new CodeVariableReferenceExpression(varAsyncResult);
inv = new CodeMethodInvokeExpression(ethis, "EndInvoke", varAsyncr);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
methodEnd.Statements.Add(dec);
methodEnd.Statements.AddRange(outAssign);
}
else
{
methodEnd.Statements.Add(inv);
}
}
else
{
method.Attributes = MemberAttributes.Public | MemberAttributes.Abstract;
}
// Attributes
ImportHeaders(method);
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Web.Services.WebMethodAttribute");
if (messageName != method.Name)
{
att.Arguments.Add(GetArg("MessageName", messageName));
}
AddCustomAttribute(method, att, (Style == ServiceDescriptionImportStyle.Server));
if (style == SoapBindingStyle.Rpc)
{
att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapRpcMethodAttribute");
att.Arguments.Add(GetArg(soapOper.SoapAction));
if (inputMembers.ElementName != method.Name)
{
att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
}
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
{
att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
}
att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null)
{
att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
}
if (outputMembers == null)
{
att.Arguments.Add(GetArg("OneWay", true));
}
}
else
{
if (outputMembers != null && (inputMembers.ElementName == "" && outputMembers.ElementName != "" ||
inputMembers.ElementName != "" && outputMembers.ElementName == ""))
{
throw new InvalidOperationException("Parameter style is not the same for the input message and output message");
}
att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapDocumentMethodAttribute");
att.Arguments.Add(GetArg(soapOper.SoapAction));
if (inputMembers.ElementName != "")
{
if (inputMembers.ElementName != method.Name)
{
att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
}
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
{
att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
}
att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null)
{
att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
}
att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Wrapped"));
}
else
{
att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Bare"));
}
if (outputMembers == null)
{
att.Arguments.Add(GetArg("OneWay", true));
}
att.Arguments.Add(GetEnumArg("Use", "System.Web.Services.Description.SoapBindingUse", bodyBinding.Use.ToString()));
}
AddCustomAttribute(method, att, true);
CodeTypeDeclaration.Members.Add(method);
if (Style == ServiceDescriptionImportStyle.Client)
{
CodeTypeDeclaration.Members.Add(methodBegin);
CodeTypeDeclaration.Members.Add(methodEnd);
}
return(method);
}
void WriteBody(XmlTextWriter xtw, Operation oper, OperationMessage opm, SoapBodyBinding sbb, SoapBindingStyle style)
{
Message msg = descriptions.GetMessage(opm.Message);
if (msg.Parts.Count > 0 && msg.Parts[0].Name == "parameters")
{
MessagePart part = msg.Parts[0];
if (part.Element == XmlQualifiedName.Empty)
{
WriteTypeSample(xtw, part.Type);
}
else
{
WriteRootElementSample(xtw, part.Element);
}
}
else
{
string elemName = oper.Name;
string ns = "";
if (opm is OperationOutput)
{
elemName += "Response";
}
if (style == SoapBindingStyle.Rpc)
{
xtw.WriteStartElement(elemName, sbb.Namespace);
ns = sbb.Namespace;
}
foreach (MessagePart part in msg.Parts)
{
if (part.Element == XmlQualifiedName.Empty)
{
XmlSchemaElement elem = new XmlSchemaElement();
elem.SchemaTypeName = part.Type;
elem.Name = part.Name;
WriteElementSample(xtw, ns, elem);
}
else
{
WriteRootElementSample(xtw, part.Element);
}
}
if (style == SoapBindingStyle.Rpc)
{
xtw.WriteEndElement();
}
}
WriteQueuedTypeSamples(xtw);
}
