internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs)
        {
            SoapReflectedMethod method2;

            try
            {
                string str2;
                string str4;
                string key = methodInfo.GetKey();
                SoapReflectedMethod method     = new SoapReflectedMethod();
                MethodAttribute     attribute  = new MethodAttribute();
                object soapServiceAttribute    = GetSoapServiceAttribute(methodInfo.DeclaringType);
                bool   serviceDefaultIsEncoded = ServiceDefaultIsEncoded(soapServiceAttribute);
                object soapMethodAttribute     = GetSoapMethodAttribute(methodInfo);
                if (soapMethodAttribute == null)
                {
                    if (client)
                    {
                        return(null);
                    }
                    if (soapServiceAttribute is SoapRpcServiceAttribute)
                    {
                        SoapRpcMethodAttribute attribute2 = new SoapRpcMethodAttribute {
                            Use = ((SoapRpcServiceAttribute)soapServiceAttribute).Use
                        };
                        soapMethodAttribute = attribute2;
                    }
                    else if (soapServiceAttribute is SoapDocumentServiceAttribute)
                    {
                        SoapDocumentMethodAttribute attribute3 = new SoapDocumentMethodAttribute {
                            Use = ((SoapDocumentServiceAttribute)soapServiceAttribute).Use
                        };
                        soapMethodAttribute = attribute3;
                    }
                    else
                    {
                        soapMethodAttribute = new SoapDocumentMethodAttribute();
                    }
                }
                if (soapMethodAttribute is SoapRpcMethodAttribute)
                {
                    SoapRpcMethodAttribute attribute4 = (SoapRpcMethodAttribute)soapMethodAttribute;
                    method.rpc             = true;
                    method.use             = attribute4.Use;
                    method.oneWay          = attribute4.OneWay;
                    attribute.action       = attribute4.Action;
                    attribute.binding      = attribute4.Binding;
                    attribute.requestName  = attribute4.RequestElementName;
                    attribute.requestNs    = attribute4.RequestNamespace;
                    attribute.responseName = attribute4.ResponseElementName;
                    attribute.responseNs   = attribute4.ResponseNamespace;
                }
                else
                {
                    SoapDocumentMethodAttribute attribute5 = (SoapDocumentMethodAttribute)soapMethodAttribute;
                    method.rpc             = false;
                    method.use             = attribute5.Use;
                    method.paramStyle      = attribute5.ParameterStyle;
                    method.oneWay          = attribute5.OneWay;
                    attribute.action       = attribute5.Action;
                    attribute.binding      = attribute5.Binding;
                    attribute.requestName  = attribute5.RequestElementName;
                    attribute.requestNs    = attribute5.RequestNamespace;
                    attribute.responseName = attribute5.ResponseElementName;
                    attribute.responseNs   = attribute5.ResponseNamespace;
                    if (method.use == SoapBindingUse.Default)
                    {
                        if (soapServiceAttribute is SoapDocumentServiceAttribute)
                        {
                            method.use = ((SoapDocumentServiceAttribute)soapServiceAttribute).Use;
                        }
                        if (method.use == SoapBindingUse.Default)
                        {
                            method.use = SoapBindingUse.Literal;
                        }
                    }
                    if (method.paramStyle == SoapParameterStyle.Default)
                    {
                        if (soapServiceAttribute is SoapDocumentServiceAttribute)
                        {
                            method.paramStyle = ((SoapDocumentServiceAttribute)soapServiceAttribute).ParameterStyle;
                        }
                        if (method.paramStyle == SoapParameterStyle.Default)
                        {
                            method.paramStyle = SoapParameterStyle.Wrapped;
                        }
                    }
                }
                if (attribute.binding.Length > 0)
                {
                    if (client)
                    {
                        throw new InvalidOperationException(System.Web.Services.Res.GetString("WebInvalidBindingPlacement", new object[] { soapMethodAttribute.GetType().Name }));
                    }
                    method.binding = WebServiceBindingReflector.GetAttribute(methodInfo, attribute.binding);
                }
                WebMethodAttribute methodAttribute = methodInfo.MethodAttribute;
                method.name = methodAttribute.MessageName;
                if (method.name.Length == 0)
                {
                    method.name = methodInfo.Name;
                }
                if (method.rpc)
                {
                    str2 = ((attribute.requestName.Length == 0) || !client) ? methodInfo.Name : attribute.requestName;
                }
                else
                {
                    str2 = (attribute.requestName.Length == 0) ? method.name : attribute.requestName;
                }
                string requestNs = attribute.requestNs;
                if (requestNs == null)
                {
                    if (((method.binding != null) && (method.binding.Namespace != null)) && (method.binding.Namespace.Length != 0))
                    {
                        requestNs = method.binding.Namespace;
                    }
                    else
                    {
                        requestNs = defaultNs;
                    }
                }
                if (method.rpc && (method.use != SoapBindingUse.Encoded))
                {
                    str4 = methodInfo.Name + "Response";
                }
                else
                {
                    str4 = (attribute.responseName.Length == 0) ? (method.name + "Response") : attribute.responseName;
                }
                string responseNs = attribute.responseNs;
                if (responseNs == null)
                {
                    if (((method.binding != null) && (method.binding.Namespace != null)) && (method.binding.Namespace.Length != 0))
                    {
                        responseNs = method.binding.Namespace;
                    }
                    else
                    {
                        responseNs = defaultNs;
                    }
                }
                SoapParameterInfo[] infoArray  = ReflectParameters(methodInfo.InParameters, requestNs);
                SoapParameterInfo[] infoArray2 = ReflectParameters(methodInfo.OutParameters, responseNs);
                method.action = attribute.action;
                if (method.action == null)
                {
                    method.action = GetDefaultAction(defaultNs, methodInfo);
                }
                method.methodInfo = methodInfo;
                if (method.oneWay)
                {
                    if (infoArray2.Length > 0)
                    {
                        throw new ArgumentException(System.Web.Services.Res.GetString("WebOneWayOutParameters"), "methodInfo");
                    }
                    if (methodInfo.ReturnType != typeof(void))
                    {
                        throw new ArgumentException(System.Web.Services.Res.GetString("WebOneWayReturnValue"), "methodInfo");
                    }
                }
                XmlReflectionMember[] members = new XmlReflectionMember[infoArray.Length];
                for (int i = 0; i < members.Length; i++)
                {
                    SoapParameterInfo   info   = infoArray[i];
                    XmlReflectionMember member = new XmlReflectionMember {
                        MemberName = info.parameterInfo.Name,
                        MemberType = info.parameterInfo.ParameterType
                    };
                    if (member.MemberType.IsByRef)
                    {
                        member.MemberType = member.MemberType.GetElementType();
                    }
                    member.XmlAttributes  = info.xmlAttributes;
                    member.SoapAttributes = info.soapAttributes;
                    members[i]            = member;
                }
                method.requestMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, method.rpc, method.use, method.paramStyle, str2, requestNs, attribute.requestNs == null, members, true, false, key, client);
                if (((GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.RequestElement) && (method.paramStyle == SoapParameterStyle.Bare)) && (method.requestMappings.Count != 1))
                {
                    throw new ArgumentException(System.Web.Services.Res.GetString("WhenUsingAMessageStyleOfParametersAsDocument0"), "methodInfo");
                }
                string name = "";
                string ns   = "";
                if (method.paramStyle == SoapParameterStyle.Bare)
                {
                    if (method.requestMappings.Count == 1)
                    {
                        name = method.requestMappings[0].XsdElementName;
                        ns   = method.requestMappings[0].Namespace;
                    }
                }
                else
                {
                    name = method.requestMappings.XsdElementName;
                    ns   = method.requestMappings.Namespace;
                }
                method.requestElementName = new XmlQualifiedName(name, ns);
                if (!method.oneWay)
                {
                    int             num2        = infoArray2.Length;
                    int             num3        = 0;
                    CodeIdentifiers identifiers = null;
                    if (methodInfo.ReturnType != typeof(void))
                    {
                        num2++;
                        num3        = 1;
                        identifiers = new CodeIdentifiers();
                    }
                    members = new XmlReflectionMember[num2];
                    for (int m = 0; m < infoArray2.Length; m++)
                    {
                        SoapParameterInfo   info2   = infoArray2[m];
                        XmlReflectionMember member2 = new XmlReflectionMember {
                            MemberName = info2.parameterInfo.Name,
                            MemberType = info2.parameterInfo.ParameterType
                        };
                        if (member2.MemberType.IsByRef)
                        {
                            member2.MemberType = member2.MemberType.GetElementType();
                        }
                        member2.XmlAttributes  = info2.xmlAttributes;
                        member2.SoapAttributes = info2.soapAttributes;
                        members[num3++]        = member2;
                        if (identifiers != null)
                        {
                            identifiers.Add(member2.MemberName, null);
                        }
                    }
                    if (methodInfo.ReturnType != typeof(void))
                    {
                        XmlReflectionMember member3 = new XmlReflectionMember {
                            MemberName    = identifiers.MakeUnique(method.name + "Result"),
                            MemberType    = methodInfo.ReturnType,
                            IsReturnValue = true,
                            XmlAttributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider)
                        };
                        member3.XmlAttributes.XmlRoot = null;
                        member3.SoapAttributes        = new SoapAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
                        members[0] = member3;
                    }
                    method.responseMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, method.rpc, method.use, method.paramStyle, str4, responseNs, attribute.responseNs == null, members, false, false, key + ":Response", !client);
                }
                SoapExtensionAttribute[] customAttributes = (SoapExtensionAttribute[])methodInfo.GetCustomAttributes(typeof(SoapExtensionAttribute));
                method.extensions = new SoapReflectedExtension[customAttributes.Length];
                for (int j = 0; j < customAttributes.Length; j++)
                {
                    method.extensions[j] = new SoapReflectedExtension(customAttributes[j].ExtensionType, customAttributes[j]);
                }
                Array.Sort <SoapReflectedExtension>(method.extensions);
                SoapHeaderAttribute[] array = (SoapHeaderAttribute[])methodInfo.GetCustomAttributes(typeof(SoapHeaderAttribute));
                Array.Sort(array, new SoapHeaderAttributeComparer());
                Hashtable hashtable = new Hashtable();
                method.headers = new SoapReflectedHeader[array.Length];
                int       num6   = 0;
                int       length = method.headers.Length;
                ArrayList list   = new ArrayList();
                ArrayList list2  = new ArrayList();
                for (int k = 0; k < method.headers.Length; k++)
                {
                    SoapHeaderAttribute attribute7 = array[k];
                    SoapReflectedHeader header     = new SoapReflectedHeader();
                    Type declaringType             = methodInfo.DeclaringType;
                    header.memberInfo = declaringType.GetField(attribute7.MemberName);
                    if (header.memberInfo != null)
                    {
                        header.headerType = ((FieldInfo)header.memberInfo).FieldType;
                    }
                    else
                    {
                        header.memberInfo = declaringType.GetProperty(attribute7.MemberName);
                        if (header.memberInfo == null)
                        {
                            throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderMissing");
                        }
                        header.headerType = ((PropertyInfo)header.memberInfo).PropertyType;
                    }
                    if (header.headerType.IsArray)
                    {
                        header.headerType = header.headerType.GetElementType();
                        header.repeats    = true;
                        if ((header.headerType != typeof(SoapUnknownHeader)) && (header.headerType != typeof(SoapHeader)))
                        {
                            throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderType");
                        }
                    }
                    if (MemberHelper.IsStatic(header.memberInfo))
                    {
                        throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderStatic");
                    }
                    if (!MemberHelper.CanRead(header.memberInfo))
                    {
                        throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderRead");
                    }
                    if (!MemberHelper.CanWrite(header.memberInfo))
                    {
                        throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderWrite");
                    }
                    if (!typeof(SoapHeader).IsAssignableFrom(header.headerType))
                    {
                        throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderType");
                    }
                    SoapHeaderDirection direction = attribute7.Direction;
                    if (method.oneWay && ((direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0))
                    {
                        throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderOneWayOut");
                    }
                    if (hashtable.Contains(header.headerType))
                    {
                        SoapHeaderDirection direction2 = (SoapHeaderDirection)hashtable[header.headerType];
                        if ((direction2 & direction) != 0)
                        {
                            throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebMultiplyDeclaredHeaderTypes");
                        }
                        hashtable[header.headerType] = direction | direction2;
                    }
                    else
                    {
                        hashtable[header.headerType] = direction;
                    }
                    if ((header.headerType != typeof(SoapHeader)) && (header.headerType != typeof(SoapUnknownHeader)))
                    {
                        XmlReflectionMember member4 = new XmlReflectionMember {
                            MemberName = header.headerType.Name,
                            MemberType = header.headerType
                        };
                        XmlAttributes attributes = new XmlAttributes(header.headerType);
                        if (attributes.XmlRoot != null)
                        {
                            member4.XmlAttributes = new XmlAttributes();
                            XmlElementAttribute attribute8 = new XmlElementAttribute {
                                ElementName = attributes.XmlRoot.ElementName,
                                Namespace   = attributes.XmlRoot.Namespace
                            };
                            member4.XmlAttributes.XmlElements.Add(attribute8);
                        }
                        member4.OverrideIsNullable = true;
                        if ((direction & SoapHeaderDirection.In) != 0)
                        {
                            list.Add(member4);
                        }
                        if ((direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0)
                        {
                            list2.Add(member4);
                        }
                        header.custom = true;
                    }
                    header.direction = direction;
                    if (!header.custom)
                    {
                        method.headers[--length] = header;
                    }
                    else
                    {
                        method.headers[num6++] = header;
                    }
                }
                method.inHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, method.use, SoapParameterStyle.Bare, str2 + "InHeaders", defaultNs, true, (XmlReflectionMember[])list.ToArray(typeof(XmlReflectionMember)), false, true, key + ":InHeaders", client);
                if (!method.oneWay)
                {
                    method.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, method.use, SoapParameterStyle.Bare, str4 + "OutHeaders", defaultNs, true, (XmlReflectionMember[])list2.ToArray(typeof(XmlReflectionMember)), false, true, key + ":OutHeaders", !client);
                }
                method2 = method;
            }
            catch (Exception exception)
            {
                if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
                {
                    throw;
                }
                throw new InvalidOperationException(System.Web.Services.Res.GetString("WebReflectionErrorMethod", new object[] { methodInfo.DeclaringType.Name, methodInfo.Name }), exception);
            }
            return(method2);
        }
예제 #2
0
        internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs)
        {
            try {
                SoapReflectedMethod soapMethod      = new SoapReflectedMethod();
                MethodAttribute     methodAttribute = new MethodAttribute();

                object serviceAttr             = GetSoapServiceAttribute(methodInfo.DeclaringType);
                bool   serviceDefaultIsEncoded = ServiceDefaultIsEncoded(serviceAttr);
                object methodAttr = GetSoapMethodAttribute(methodInfo);
                if (methodAttr == null)
                {
                    if (client)
                    {
                        return(null);        // method attribute required on the client
                    }
                    if (serviceAttr is SoapRpcServiceAttribute)
                    {
                        methodAttr = new SoapRpcMethodAttribute();
                    }
                    else
                    {
                        methodAttr = new SoapDocumentMethodAttribute();
                    }
                }

                if (methodAttr is SoapRpcMethodAttribute)
                {
                    SoapRpcMethodAttribute attr = (SoapRpcMethodAttribute)methodAttr;

                    soapMethod.rpc               = true;
                    soapMethod.use               = SoapBindingUse.Encoded;
                    soapMethod.oneWay            = attr.OneWay;
                    methodAttribute.action       = attr.Action;
                    methodAttribute.binding      = attr.Binding;
                    methodAttribute.requestName  = attr.RequestElementName;
                    methodAttribute.requestNs    = attr.RequestNamespace;
                    methodAttribute.responseName = attr.ResponseElementName;
                    methodAttribute.responseNs   = attr.ResponseNamespace;
                }
                else
                {
                    SoapDocumentMethodAttribute attr = (SoapDocumentMethodAttribute)methodAttr;

                    soapMethod.rpc               = false;
                    soapMethod.use               = attr.Use;
                    soapMethod.paramStyle        = attr.ParameterStyle;
                    soapMethod.oneWay            = attr.OneWay;
                    methodAttribute.action       = attr.Action;
                    methodAttribute.binding      = attr.Binding;
                    methodAttribute.requestName  = attr.RequestElementName;
                    methodAttribute.requestNs    = attr.RequestNamespace;
                    methodAttribute.responseName = attr.ResponseElementName;
                    methodAttribute.responseNs   = attr.ResponseNamespace;

                    if (soapMethod.use == SoapBindingUse.Default)
                    {
                        if (serviceAttr is SoapDocumentServiceAttribute)
                        {
                            soapMethod.use = ((SoapDocumentServiceAttribute)serviceAttr).Use;
                        }
                        if (soapMethod.use == SoapBindingUse.Default)
                        {
                            soapMethod.use = SoapBindingUse.Literal;
                        }
                    }
                    if (soapMethod.paramStyle == SoapParameterStyle.Default)
                    {
                        if (serviceAttr is SoapDocumentServiceAttribute)
                        {
                            soapMethod.paramStyle = ((SoapDocumentServiceAttribute)serviceAttr).ParameterStyle;
                        }
                        if (soapMethod.paramStyle == SoapParameterStyle.Default)
                        {
                            soapMethod.paramStyle = SoapParameterStyle.Wrapped;
                        }
                    }
                }

                if (methodAttribute.binding.Length > 0)
                {
                    if (client)
                    {
                        throw new InvalidOperationException(Res.GetString(Res.WebInvalidBindingPlacement, methodAttr.GetType().Name));
                    }
                    soapMethod.binding = WebServiceBindingReflector.GetAttribute(methodInfo, methodAttribute.binding);
                }

                WebMethodAttribute webMethodAttribute = WebMethodReflector.GetAttribute(methodInfo);
                soapMethod.name = webMethodAttribute.MessageName;
                if (soapMethod.name.Length == 0)
                {
                    soapMethod.name = methodInfo.Name;
                }

                string requestElementName;
                if (soapMethod.rpc)
                {
                    requestElementName = methodInfo.Name;
                }
                else
                {
                    requestElementName = methodAttribute.requestName.Length == 0 ? soapMethod.name : methodAttribute.requestName;
                }
                string requestNamespace = methodAttribute.requestNs;

                if (requestNamespace == null)
                {
                    if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0)
                    {
                        requestNamespace = soapMethod.binding.Namespace;
                    }
                    else
                    {
                        requestNamespace = defaultNs;
                    }
                }

                string responseElementName = methodAttribute.responseName.Length == 0 ? soapMethod.name + "Response": methodAttribute.responseName;
                string responseNamespace   = methodAttribute.responseNs;

                if (responseNamespace == null)
                {
                    if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0)
                    {
                        responseNamespace = soapMethod.binding.Namespace;
                    }
                    else
                    {
                        responseNamespace = defaultNs;
                    }
                }

                SoapParameterInfo[] inParameters  = ReflectParameters(methodInfo.InParameters, requestNamespace);
                SoapParameterInfo[] outParameters = ReflectParameters(methodInfo.OutParameters, responseNamespace);

                soapMethod.action = methodAttribute.action;
                if (soapMethod.action == null)
                {
                    soapMethod.action = GetDefaultAction(defaultNs, methodInfo);
                }
                soapMethod.methodInfo = methodInfo;

                if (soapMethod.oneWay)
                {
                    if (outParameters.Length > 0)
                    {
                        throw new ArgumentException(Res.GetString(Res.WebOneWayOutParameters), "methodInfo");
                    }
                    if (methodInfo.ReturnType != typeof(void))
                    {
                        throw new ArgumentException(Res.GetString(Res.WebOneWayReturnValue), "methodInfo");
                    }
                }

                XmlReflectionMember[] members = new XmlReflectionMember[inParameters.Length];
                for (int i = 0; i < members.Length; i++)
                {
                    SoapParameterInfo   soapParamInfo = inParameters[i];
                    XmlReflectionMember member        = new XmlReflectionMember();
                    member.MemberName = soapParamInfo.parameterInfo.Name;
                    member.MemberType = soapParamInfo.parameterInfo.ParameterType;
                    if (member.MemberType.IsByRef)
                    {
                        member.MemberType = member.MemberType.GetElementType();
                    }
                    member.XmlAttributes  = soapParamInfo.xmlAttributes;
                    member.SoapAttributes = soapParamInfo.soapAttributes;
                    members[i]            = member;
                }
                soapMethod.requestMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, requestElementName, requestNamespace, methodAttribute.requestNs == null, members, true);

                if (GetSoapServiceRoutingStyle(serviceAttr) == SoapServiceRoutingStyle.RequestElement &&
                    soapMethod.paramStyle == SoapParameterStyle.Bare &&
                    soapMethod.requestMappings.Count != 1)
                {
                    throw new ArgumentException(Res.GetString(Res.WhenUsingAMessageStyleOfParametersAsDocument0), "methodInfo");
                }

                string elementName      = "";
                string elementNamespace = "";
                if (soapMethod.paramStyle == SoapParameterStyle.Bare)
                {
                    if (soapMethod.requestMappings.Count == 1)
                    {
                        elementName      = soapMethod.requestMappings[0].ElementName;
                        elementNamespace = soapMethod.requestMappings[0].Namespace;
                    }
                    // else: can't route on request element -- we match on an empty qname,
                    //       normal rules apply for duplicates
                }
                else
                {
                    elementName      = soapMethod.requestMappings.ElementName;
                    elementNamespace = soapMethod.requestMappings.Namespace;
                }
                soapMethod.requestElementName = new XmlQualifiedName(elementName, elementNamespace);

                if (!soapMethod.oneWay)
                {
                    int             numOutParams = outParameters.Length;
                    int             count        = 0;
                    CodeIdentifiers identifiers  = null;
                    if (methodInfo.ReturnType != typeof(void))
                    {
                        numOutParams++;
                        count       = 1;
                        identifiers = new CodeIdentifiers();
                    }
                    members = new XmlReflectionMember[numOutParams];

                    for (int i = 0; i < outParameters.Length; i++)
                    {
                        SoapParameterInfo   soapParamInfo = outParameters[i];
                        XmlReflectionMember member        = new XmlReflectionMember();
                        member.MemberName = soapParamInfo.parameterInfo.Name;
                        member.MemberType = soapParamInfo.parameterInfo.ParameterType;
                        if (member.MemberType.IsByRef)
                        {
                            member.MemberType = member.MemberType.GetElementType();
                        }
                        member.XmlAttributes  = soapParamInfo.xmlAttributes;
                        member.SoapAttributes = soapParamInfo.soapAttributes;
                        members[count++]      = member;
                        if (identifiers != null)
                        {
                            identifiers.Add(member.MemberName, null);
                        }
                    }
                    if (methodInfo.ReturnType != typeof(void))
                    {
                        XmlReflectionMember member = new XmlReflectionMember();
                        member.MemberName    = identifiers.MakeUnique(soapMethod.name + "Result");
                        member.MemberType    = methodInfo.ReturnType;
                        member.IsReturnValue = true;

                        member.XmlAttributes         = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
                        member.XmlAttributes.XmlRoot = null; // Ignore XmlRoot attribute used by get/post
                        member.SoapAttributes        = new SoapAttributes(methodInfo.ReturnTypeCustomAttributeProvider);

                        members[0] = member;
                    }
                    soapMethod.responseMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, responseElementName, responseNamespace, methodAttribute.responseNs == null, members, false);
                }

                SoapExtensionAttribute[] extensionAttributes = (SoapExtensionAttribute[])methodInfo.GetCustomAttributes(typeof(SoapExtensionAttribute));
                soapMethod.extensions = new SoapReflectedExtension[extensionAttributes.Length];
                for (int i = 0; i < extensionAttributes.Length; i++)
                {
                    soapMethod.extensions[i] = new SoapReflectedExtension(extensionAttributes[i].ExtensionType, extensionAttributes[i]);
                }
                Array.Sort(soapMethod.extensions);

                SoapHeaderAttribute[] headerAttributes = (SoapHeaderAttribute[])methodInfo.GetCustomAttributes(typeof(SoapHeaderAttribute));
                Array.Sort(headerAttributes, new SoapHeaderAttributeComparer());
                Hashtable headerTypes = new Hashtable();
                soapMethod.headers = new SoapReflectedHeader[headerAttributes.Length];
                int       front      = 0;
                int       back       = soapMethod.headers.Length;
                ArrayList inHeaders  = new ArrayList();
                ArrayList outHeaders = new ArrayList();
                for (int i = 0; i < soapMethod.headers.Length; i++)
                {
                    SoapHeaderAttribute headerAttribute = headerAttributes[i];
                    SoapReflectedHeader soapHeader      = new SoapReflectedHeader();
                    Type declaringType = methodInfo.DeclaringType;
                    if ((soapHeader.memberInfo = declaringType.GetField(headerAttribute.MemberName)) != null)
                    {
                        soapHeader.headerType = ((FieldInfo)soapHeader.memberInfo).FieldType;
                    }
                    else if ((soapHeader.memberInfo = declaringType.GetProperty(headerAttribute.MemberName)) != null)
                    {
                        soapHeader.headerType = ((PropertyInfo)soapHeader.memberInfo).PropertyType;
                    }
                    else
                    {
                        throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderMissing);
                    }
                    if (soapHeader.headerType.IsArray)
                    {
                        soapHeader.headerType = soapHeader.headerType.GetElementType();
                        soapHeader.repeats    = true;
                        if (soapHeader.headerType != typeof(SoapUnknownHeader) && soapHeader.headerType != typeof(SoapHeader))
                        {
                            throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType);
                        }
                    }
                    if (MemberHelper.IsStatic(soapHeader.memberInfo))
                    {
                        throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderStatic);
                    }
                    if (!MemberHelper.CanRead(soapHeader.memberInfo))
                    {
                        throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderRead);
                    }
                    if (!MemberHelper.CanWrite(soapHeader.memberInfo))
                    {
                        throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderWrite);
                    }
                    if (!typeof(SoapHeader).IsAssignableFrom(soapHeader.headerType))
                    {
                        throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType);
                    }

                    SoapHeaderDirection direction = headerAttribute.Direction;
                    if (soapMethod.oneWay && (direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
                    {
                        throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderOneWayOut);
                    }
                    if (headerTypes.Contains(soapHeader.headerType))
                    {
                        SoapHeaderDirection prevDirection = (SoapHeaderDirection)headerTypes[soapHeader.headerType];
                        if ((prevDirection & direction) != 0)
                        {
                            throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebMultiplyDeclaredHeaderTypes);
                        }
                        headerTypes[soapHeader.headerType] = direction | prevDirection;
                    }
                    else
                    {
                        headerTypes[soapHeader.headerType] = direction;
                    }

                    if (soapHeader.headerType != typeof(SoapHeader) && soapHeader.headerType != typeof(SoapUnknownHeader))
                    {
                        XmlReflectionMember member = new XmlReflectionMember();
                        member.MemberName         = soapHeader.headerType.Name;
                        member.MemberType         = soapHeader.headerType;
                        member.OverrideIsNullable = true;

                        if ((direction & SoapHeaderDirection.In) != 0)
                        {
                            inHeaders.Add(member);
                        }
                        if ((direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
                        {
                            outHeaders.Add(member);
                        }

                        soapHeader.custom = true;
                    }
                    soapHeader.direction = direction;
                    // Put generic header mappings at the end of the list so they are found last during header processing
                    if (!soapHeader.custom)
                    {
                        soapMethod.headers[--back] = soapHeader;
                    }
                    else
                    {
                        soapMethod.headers[front++] = soapHeader;
                    }
                }
                soapMethod.inHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, "InHeaders", defaultNs, true, (XmlReflectionMember[])inHeaders.ToArray(typeof(XmlReflectionMember)), false);
                if (!soapMethod.oneWay)
                {
                    soapMethod.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, "OutHeaders", defaultNs, true, (XmlReflectionMember[])outHeaders.ToArray(typeof(XmlReflectionMember)), false);
                }

                return(soapMethod);
            }
            catch (Exception e) {
                throw new InvalidOperationException(Res.GetString(Res.WebReflectionErrorMethod, methodInfo.DeclaringType.Name, methodInfo.Name), e);
            }
        }