Пример #1
0
        public void MemberNameDefault()
        {
            SoapSchemaMember member = new SoapSchemaMember();

            Assert.AreEqual(string.Empty, member.MemberName);

            member.MemberName = null;
            Assert.AreEqual(string.Empty, member.MemberName);
        }
 XmlMembersMapping ImportInMembersMapping(Message msg)
 {
     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;
     }
     return(soapImporter.ImportMembersMapping(Operation.Name, "", mems));
 }
 /// <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));
     }
 }
Пример #4
0
        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));
                    }
                }
            }
        }
Пример #5
0
        public void MemberTypeDefault()
        {
            SoapSchemaMember member = new SoapSchemaMember();

            Assert.AreEqual(XmlQualifiedName.Empty, member.MemberType);
        }
 public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember member)
 {
 }
 public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members)
 {
 }
 public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement, Type baseType, bool baseTypeCanBeIndirect)
 {
 }
 public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement)
 {
 }