public string GetMethodName(Type type)
        {
            if (MethodNames.TryGetValue(type, out var method))
            {
                return(method);
            }

            // Custom method
            var attribute = MethodAttribute.From(type);

            var handler = KnownHandlers.SelectMany(z => z)
                          .FirstOrDefault(z => z.InterfaceType == type || z.HandlerType == type || z.ParamsType == type);

            if (handler != null)
            {
                return(handler.Method);
            }

            // TODO: Log unknown method name
            if (attribute is null)
            {
                return(null);
            }

            MethodNames.TryAdd(type, attribute.Method);
            return(attribute.Method);
        }
            public TypeHandlerExtensionData()
            {
                var handlerTypeDescriptorProvider = new HandlerTypeDescriptorProvider(
                    new[] {
                    typeof(HandlerTypeDescriptorProvider).Assembly,
                    typeof(DebugAdapterRpcOptionsBase <>).Assembly,
                    typeof(DebugAdapterClient).Assembly,
                    typeof(DebugAdapterServer).Assembly,
                    typeof(DapReceiver).Assembly,
                    typeof(DebugAdapterProtocolTestBase).Assembly
                }
                    );

                foreach (var type in typeof(CompletionsArguments).Assembly.ExportedTypes
                         .Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)))
                {
                    if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
                    {
                        continue;
                    }
                    if (type == typeof(IProgressStartHandler) || type == typeof(IProgressUpdateHandler) || type == typeof(IProgressEndHandler))
                    {
                        continue;
                    }
                    var descriptor = handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type) !;

                    Add(
                        descriptor,
                        GetOnMethodName(descriptor),
                        GetSendMethodName(descriptor),
                        GetExtensionClass(descriptor),
                        GetExtensionClassName(descriptor).Substring(GetExtensionClassName(descriptor).LastIndexOf('.') + 1)
                        );
                }
            }
        public void Decorate <T>(T instance)
        {
            PropertyInfo[] properties = instance.GetType().GetProperties();
            foreach (PropertyInfo property in properties)
            {
                Object[] attributes = (Object[])property.GetCustomAttributes(typeof(Attribute), true);
                foreach (Object obj in attributes)
                {
                    PropertyAttribute propertyAttribute = _instantiator.GetInstanceByType <PropertyAttribute>(obj.GetType(), new Object[0]);
                    propertyAttribute.Decorator = this;
                    propertyAttribute.DecorateProperty(instance, property);
                }
            }

            MethodInfo[] methods = instance.GetType().GetMethods();
            foreach (MethodInfo method in methods)
            {
                Object[] attributes = (Object[])method.GetCustomAttributes(typeof(MethodAttribute), true);
                for (int j = attributes.Length - 1; j >= 0; j--)
                {
                    Object          obj             = attributes[j];
                    MethodAttribute methodAttribute = _instantiator.GetInstanceByType <MethodAttribute>(obj.GetType(), new Object[0]);
                    methodAttribute.Decorator = this;
                    methodAttribute.DecorateMethod(instance, method);
                }
            }
        }
            public TypeHandlerData()
            {
                var handlerTypeDescriptorProvider = new HandlerTypeDescriptorProvider(
                    new[] {
                    typeof(HandlerTypeDescriptorProvider).Assembly,
                    typeof(DebugAdapterRpcOptionsBase <>).Assembly,
                    typeof(DebugAdapterClient).Assembly,
                    typeof(DebugAdapterServer).Assembly,
                    typeof(DapReceiver).Assembly,
                    typeof(DebugAdapterProtocolTestBase).Assembly
                }
                    );

                foreach (var type in typeof(CompletionsArguments).Assembly.ExportedTypes.Where(
                             z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)
                             ))
                {
                    if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
                    {
                        continue;
                    }
                    if (type == typeof(IProgressStartHandler) || type == typeof(IProgressUpdateHandler) || type == typeof(IProgressEndHandler))
                    {
                        continue;
                    }

                    Add(handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type) !);
                }
            }
            public TypeHandlerData()
            {
                var handlerTypeDescriptorProvider =
                    new LspHandlerTypeDescriptorProvider(
                        new[]
                {
                    typeof(AssemblyScanningHandlerTypeDescriptorProvider).Assembly,
                    typeof(LspHandlerTypeDescriptorProvider).Assembly,
                    typeof(LanguageServer).Assembly,
                    typeof(LanguageClient).Assembly,
                    typeof(ISupports).Assembly,
                    typeof(HandlerResolverTests).Assembly
                }
                        );

                foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z))
                         .Where(z => !z.Name.EndsWith("Manager"))
                         .Except(new[] { typeof(ITextDocumentSyncHandler), typeof(IExecuteCommandHandler <>) })
                         )
                {
                    if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
                    {
                        continue;
                    }
                    Add(handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type) !);
                }
            }
            public TypeHandlerExtensionData()
            {
                var handlerTypeDescriptorProvider =
                    new LspHandlerTypeDescriptorProvider(
                        new[]
                {
                    typeof(AssemblyScanningHandlerTypeDescriptorProvider).Assembly,
                    typeof(LspHandlerTypeDescriptorProvider).Assembly,
                    typeof(LanguageServer).Assembly,
                    typeof(LanguageClient).Assembly,
                    typeof(ISupports).Assembly,
                    typeof(HandlerResolverTests).Assembly
                }
                        );

                foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes
                         .Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z))
                         .Where(z => !z.Name.EndsWith("Manager"))
                         .Except(new[] { typeof(ITextDocumentSyncHandler) })
                         )
                {
                    if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
                    {
                        continue;
                    }
                    if (type.Name.EndsWith("Manager"))
                    {
                        continue;
                    }
                    if (type == typeof(IExecuteCommandHandler <>))
                    {
                        continue;
                    }
                    if (type == typeof(ICompletionResolveHandler) || type == typeof(ICodeLensResolveHandler) || type == typeof(IDocumentLinkResolveHandler) ||
                        type == typeof(ICodeActionResolveHandler))
                    {
                        continue;
                    }
                    if (type == typeof(ISemanticTokensFullHandler) || type == typeof(ISemanticTokensDeltaHandler) ||
                        type == typeof(ISemanticTokensRangeHandler))
                    {
                        continue;
                    }
                    var descriptor = handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type);

                    if (descriptor == null)
                    {
                        throw new Exception("");
                    }

                    Add(
                        descriptor,
                        GetOnMethodName(descriptor),
                        GetSendMethodName(descriptor),
                        GetExtensionClass(descriptor),
                        GetExtensionClassName(descriptor).Substring(GetExtensionClassName(descriptor).LastIndexOf('.') + 1)
                        );
                }
            }
Exemple #7
0
        /// <summary>
        /// 添加Service
        /// </summary>
        /// <param name="type"></param>
        public static void AddService(Type type)
        {
            MethodAttribute attr = (MethodAttribute)type.GetCustomAttribute(typeof(MethodAttribute));

            if (attr != null && typeof(ITigerMethod).IsAssignableFrom(type))
            {
                Global.Service.Add(attr.Name, type);
            }
        }
        public void HandlersShouldMatchParamsMethodAttribute(Type type)
        {
            var paramsType = HandlerTypeDescriptorHelper.GetHandlerInterface(type).GetGenericArguments()[0];

            var lhs = MethodAttribute.From(type) !;
            var rhs = MethodAttribute.From(paramsType) !;

            lhs.Method.Should().Be(rhs.Method, $"{type.FullName} method does not match {paramsType.FullName}");
            lhs.Direction.Should().Be(rhs.Direction, $"{type.FullName} direction does not match {paramsType.FullName}");
        }
 public HandlersShouldAbstractClassData()
 {
     foreach (var type in typeof(IDataBreakpointInfoHandler).Assembly.ExportedTypes
              .Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)))
     {
         if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
         {
             continue;
         }
         Add(type);
     }
 }
        public void ShouldDecorateMethodsOnInstantiatedObjects()
        {
            inst.obj = new MockMethod();

            MockObject2 obj = new MockObject2();

            decorator.Decorate(obj);

            MethodAttribute pa = obj.AttributeMethod;

            Assert.IsNotNull(((MockMethod)pa).Obj);
            Assert.IsNotNull(((MockMethod)pa).MethodInformation);
            Assert.AreEqual("DecoratedMethod", ((MockMethod)pa).MethodInformation.Name);
        }
 public HandlersShouldHaveMethodAttributeData()
 {
     foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z))
              .Where(z => !z.Name.EndsWith("Manager"))
              .Except(new[] { typeof(ITextDocumentSyncHandler) })
              )
     {
         if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
         {
             continue;
         }
         Add(type);
     }
 }
            public TypeHandlerData()
            {
                foreach (var type in typeof(CompletionsArguments).Assembly.ExportedTypes.Where(
                             z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)
                             ))
                {
                    if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
                    {
                        continue;
                    }
                    if (type == typeof(IProgressStartHandler) || type == typeof(IProgressUpdateHandler) || type == typeof(IProgressEndHandler))
                    {
                        continue;
                    }

                    Add(HandlerTypeDescriptorHelper.GetHandlerTypeDescriptor(type));
                }
            }
Exemple #13
0
        public static void RemoveService(string itemFullPath)
        {
            FileInfo fileInfo = new FileInfo(itemFullPath);

            if (Global.PackageItem.ContainsKey(fileInfo.DirectoryName))
            {
                PackageItem packageItem = Global.PackageItem[itemFullPath];
                foreach (Type type in packageItem.Assembly.GetExportedTypes())
                {
                    MethodAttribute attr = (MethodAttribute)type.GetCustomAttribute(typeof(MethodAttribute));
                    if (attr != null && typeof(ITigerMethod).IsAssignableFrom(type))
                    {
                        if (Global.Service.ContainsKey(attr.Name))
                        {
                            Global.Service.Remove(attr.Name);
                        }
                    }
                }
                Global.PackageItem.Remove(fileInfo.DirectoryName);
            }
        }
Exemple #14
0
 public static void RemoveService(string filePath)
 {
     string[] keys = Global.PackageItem.Keys.ToArray();
     for (int i = 0; i < keys.Length; i++)
     {
         PackageItem packageItem = Global.PackageItem[keys[i]];
         if (packageItem.FileFullPath.Equals(filePath))
         {
             foreach (Type type in packageItem.Assembly.GetExportedTypes())
             {
                 MethodAttribute attr = (MethodAttribute)type.GetCustomAttribute(typeof(MethodAttribute));
                 if (attr != null && typeof(ITigerMethod).IsAssignableFrom(type))
                 {
                     Global.Service.Remove(attr.Name);
                 }
             }
             Global.PackageItem.Remove(packageItem.AssemblyName);
             break;
         }
     }
 }
            public TypeHandlerExtensionData()
            {
                foreach (var type in typeof(CompletionsArguments).Assembly.ExportedTypes
                         .Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)))
                {
                    if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
                    {
                        continue;
                    }
                    if (type == typeof(IProgressStartHandler) || type == typeof(IProgressUpdateHandler) || type == typeof(IProgressEndHandler))
                    {
                        continue;
                    }
                    var descriptor = HandlerTypeDescriptorHelper.GetHandlerTypeDescriptor(type);

                    Add(
                        descriptor,
                        GetOnMethodName(descriptor),
                        GetSendMethodName(descriptor),
                        GetExtensionClass(descriptor),
                        GetExtensionClassName(descriptor).Substring(GetExtensionClassName(descriptor).LastIndexOf('.') + 1)
                        );
                }
            }
Exemple #16
0
        static async Task AcceptInfo(HttpContext hc, Func <Task> n)
        {
            List <PackageInfo> packageInfos = new List <PackageInfo>();

            foreach (var item in Global.PackageItem)
            {
                PackageInfo packageInfo = new PackageInfo
                {
                    Item = item.Value
                };
                foreach (Type type in item.Value.Assembly.GetExportedTypes())
                {
                    MethodAttribute attr = (MethodAttribute)type.GetCustomAttribute(typeof(MethodAttribute));
                    if (attr != null && typeof(ITigerMethod).IsAssignableFrom(type))
                    {
                        packageInfo.Service.Add(attr);
                    }
                }
                packageInfos.Add(packageInfo);
            }

            hc.Response.ContentType = CommonConstant.CONTENT_TYPE;
            await hc.Response.WriteAsync(JsonConvert.SerializeObject(packageInfos), Encoding.UTF8);
        }
Exemple #17
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);
            }
        }
 public void HandlersShouldHaveMethodAttribute(Type type)
 {
     MethodAttribute.AllFrom(type).Any(z => z.Direction != Direction.Unspecified).Should()
     .Be(true, $"{type.Name} is missing a method attribute or the direction is not specified");
 }
 public void SetUp()
 {
     _attribute = new MethodAttribute(HttpMethod.Get, HttpMethod.Post);
     _route     = new Route.Routing.Route("name", Guid.NewGuid(), "relative");
     _container = MockRepository.GenerateMock <IContainer>();
 }
        internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs) {
            try {
                string methodId = methodInfo.GetKey();
                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) {
                        SoapRpcMethodAttribute method = new SoapRpcMethodAttribute();
                        method.Use = ((SoapRpcServiceAttribute)serviceAttr).Use;
                        methodAttr = method;
                    }
                    else if (serviceAttr is SoapDocumentServiceAttribute) {
                        SoapDocumentMethodAttribute method = new SoapDocumentMethodAttribute();
                        method.Use = ((SoapDocumentServiceAttribute)serviceAttr).Use;
                        methodAttr = method;
                    }
                    else {
                        methodAttr = new SoapDocumentMethodAttribute();
                    }
                }

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

                    soapMethod.rpc = true;
                    soapMethod.use = attr.Use;
                    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 = methodInfo.MethodAttribute;

                // 
                soapMethod.name = webMethodAttribute.MessageName;
                if (soapMethod.name.Length == 0) soapMethod.name = methodInfo.Name;

                string requestElementName;
                if (soapMethod.rpc) {
                    // in the case when we interop with non .net we might need to chnage the method name.
                    requestElementName = methodAttribute.requestName.Length == 0 || !client ? methodInfo.Name : methodAttribute.requestName;
                }
                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;
                if (soapMethod.rpc && soapMethod.use != SoapBindingUse.Encoded)
                {
                    // NOTE: this rule should apply equally to rpc/lit and rpc/enc, but to reduce risk, i'm only applying it to rpc/lit
                    responseElementName = methodInfo.Name + "Response";
                }
                else
                {
                    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, false, methodId, client);

                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].XsdElementName;
                        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.XsdElementName;
                    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, false, methodId + ":Response", !client);

                }

                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;

                        XmlAttributes a = new XmlAttributes(soapHeader.headerType);
                        if (a.XmlRoot != null) {
                            member.XmlAttributes = new XmlAttributes();
                            XmlElementAttribute attr = new XmlElementAttribute();
                            attr.ElementName = a.XmlRoot.ElementName;
                            attr.Namespace = a.XmlRoot.Namespace;
                            member.XmlAttributes.XmlElements.Add(attr);
                        }
                        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, requestElementName + "InHeaders", defaultNs, true, (XmlReflectionMember[]) inHeaders.ToArray(typeof(XmlReflectionMember)), false, true, methodId + ":InHeaders", client);
                if (!soapMethod.oneWay)
                    soapMethod.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, responseElementName + "OutHeaders", defaultNs, true, (XmlReflectionMember[]) outHeaders.ToArray(typeof(XmlReflectionMember)), false, true, methodId + ":OutHeaders", !client);
                
                return soapMethod;
            }
            catch (Exception e) {
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                    throw;
                }
                throw new InvalidOperationException(Res.GetString(Res.WebReflectionErrorMethod, methodInfo.DeclaringType.Name, methodInfo.Name), e);
            }
        }
        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);
        }
 /// <summary>
 /// 获取 TCP 服务函数信息
 /// </summary>
 /// <param name="type"></param>
 /// <param name="method"></param>
 /// <param name="serverAttribute"></param>
 /// <param name="methodAttribute"></param>
 /// <returns></returns>
 protected override Method <ServerAttribute, MethodAttribute, ServerSocketSender> get(Type type, MethodInfo method, ServerAttribute serverAttribute, MethodAttribute methodAttribute)
 {
     return(new Method <ServerAttribute, TcpServer.MethodAttribute, ServerSocketSender>(type, method, serverAttribute, methodAttribute, IsClient));
 }
 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;
 }