internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos)
 {
     if (methodInfos.Length == 0)
     {
         return new object[0];
     }
     WebServiceAttribute attribute = WebServiceReflector.GetAttribute(methodInfos);
     bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos));
     XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(attribute.Namespace, serviceDefaultIsEncoded);
     WebMethodReflector.IncludeTypes(methodInfos, importer);
     ArrayList list = new ArrayList();
     bool[] flagArray = new bool[methodInfos.Length];
     for (int i = 0; i < methodInfos.Length; i++)
     {
         LogicalMethodInfo methodInfo = methodInfos[i];
         Type returnType = methodInfo.ReturnType;
         if (IsSupported(returnType) && HttpServerProtocol.AreUrlParametersSupported(methodInfo))
         {
             XmlAttributes attributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
             XmlTypeMapping mapping = importer.ImportTypeMapping(returnType, attributes.XmlRoot);
             mapping.SetKey(methodInfo.GetKey() + ":Return");
             list.Add(mapping);
             flagArray[i] = true;
         }
     }
     if (list.Count == 0)
     {
         return new object[0];
     }
     XmlMapping[] mappings = (XmlMapping[]) list.ToArray(typeof(XmlMapping));
     Evidence evidenceForType = GetEvidenceForType(methodInfos[0].DeclaringType);
     TraceMethod caller = Tracing.On ? new TraceMethod(typeof(XmlReturn), "GetInitializers", methodInfos) : null;
     if (Tracing.On)
     {
         Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappings, evidenceForType }));
     }
     XmlSerializer[] serializerArray = null;
     if (AppDomain.CurrentDomain.IsHomogenous)
     {
         serializerArray = XmlSerializer.FromMappings(mappings);
     }
     else
     {
         serializerArray = XmlSerializer.FromMappings(mappings, evidenceForType);
     }
     if (Tracing.On)
     {
         Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller);
     }
     object[] objArray = new object[methodInfos.Length];
     int num2 = 0;
     for (int j = 0; j < objArray.Length; j++)
     {
         if (flagArray[j])
         {
             objArray[j] = serializerArray[num2++];
         }
     }
     return objArray;
 }

        public SoapServerMethod(Type serverType, LogicalMethodInfo methodInfo) {
            this.methodInfo = methodInfo;

            //
            // Set up the XmlImporter, the SoapImporter, and acquire
            // the ServiceAttribute on the serverType for use in
            // creating a SoapReflectedMethod.
            //
            WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(serverType);
            string serviceNamespace = serviceAttribute.Namespace;
            bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(serverType);

            SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded);
            XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded);

            //
            // Add some types relating to the methodInfo into the two importers
            //
            SoapReflector.IncludeTypes(methodInfo, soapImporter);
            WebMethodReflector.IncludeTypes(methodInfo, xmlImporter);

            //
            // Create a SoapReflectedMethod by reflecting on the
            // LogicalMethodInfo passed to us.
            //
            SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, false, xmlImporter, soapImporter, serviceNamespace);

            //
            // Most of the fields in this class are ----ed in from the reflected information
            //
            ImportReflectedMethod(soapMethod);
            ImportSerializers(soapMethod, GetServerTypeEvidence(serverType));
            ImportHeaderSerializers(soapMethod);
        }

		public SoapServerMethod (Type serverType, LogicalMethodInfo methodInfo)
		{
			TypeStubInfo type = TypeStubManager.GetTypeStub (serverType, "Soap");
			info = type.GetMethod (methodInfo.Name) as SoapMethodStubInfo;
			if (info == null)
				throw new InvalidOperationException ("Argument methodInfo does not seem to be a member of the server type.");
		}

 /// <summary>
 /// When the SOAP extension is accessed for the first time, the XML Web
 /// service method it is applied to is accessed to store the file
 /// name passed in, using the corresponding SoapExtensionAttribute.
 /// </summary>
 /// <param name="methodInfo">The method being called.</param>
 /// <param name="attribute">Decorating attribute for the method.</param>
 /// <returns>An initializer object.</returns>
 /// <exception cref="ArgumentNullException">Thrown if
 /// <paramref name="methodInfo"/> is null.</exception>
 public override object GetInitializer(LogicalMethodInfo methodInfo,
     SoapExtensionAttribute attribute) {
   if (methodInfo == null) {
     throw new ArgumentNullException("methodInfo");
   }
   return methodInfo.DeclaringType;
 }

 internal static string GetSoapMethodBinding(LogicalMethodInfo method)
 {
     string binding;
     object[] customAttributes = method.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
     if (customAttributes.Length == 0)
     {
         customAttributes = method.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
         if (customAttributes.Length == 0)
         {
             binding = string.Empty;
         }
         else
         {
             binding = ((SoapRpcMethodAttribute) customAttributes[0]).Binding;
         }
     }
     else
     {
         binding = ((SoapDocumentMethodAttribute) customAttributes[0]).Binding;
     }
     if (method.Binding == null)
     {
         return binding;
     }
     if ((binding.Length > 0) && (binding != method.Binding.Name))
     {
         throw new InvalidOperationException(System.Web.Services.Res.GetString("WebInvalidBindingName", new object[] { binding, method.Binding.Name }));
     }
     return method.Binding.Name;
 }

		public override object GetInitializer (LogicalMethodInfo methodInfo)
		{
			LogicalTypeInfo sti = TypeStubManager.GetLogicalTypeInfo (methodInfo.DeclaringType);
			object[] ats = methodInfo.ReturnTypeCustomAttributeProvider.GetCustomAttributes (typeof(XmlRootAttribute), true);
			XmlRootAttribute root = ats.Length > 0 ? ats[0] as XmlRootAttribute : null; 
			return new XmlSerializer (methodInfo.ReturnType, null, null, root, sti.GetWebServiceLiteralNamespace (sti.WebServiceNamespace));
		}

 internal static WebServiceBindingAttribute GetAttribute(LogicalMethodInfo methodInfo, string binding)
 {
     if (methodInfo.Binding != null)
     {
         if ((binding.Length > 0) && (methodInfo.Binding.Name != binding))
         {
             throw new InvalidOperationException(Res.GetString("WebInvalidBindingName", new object[] { binding, methodInfo.Binding.Name }));
         }
         return methodInfo.Binding;
     }
     Type declaringType = methodInfo.DeclaringType;
     object[] customAttributes = declaringType.GetCustomAttributes(typeof(WebServiceBindingAttribute), false);
     WebServiceBindingAttribute attribute = null;
     foreach (WebServiceBindingAttribute attribute2 in customAttributes)
     {
         if (attribute2.Name == binding)
         {
             if (attribute != null)
             {
                 throw new ArgumentException(Res.GetString("MultipleBindingsWithSameName2", new object[] { declaringType.FullName, binding, "methodInfo" }));
             }
             attribute = attribute2;
         }
     }
     if (((attribute == null) && (binding != null)) && (binding.Length > 0))
     {
         throw new ArgumentException(Res.GetString("TypeIsMissingWebServiceBindingAttributeThat2", new object[] { declaringType.FullName, binding }), "methodInfo");
     }
     return attribute;
 }

 public override object GetInitializer(LogicalMethodInfo methodInfo)
 {
     if (!ValueCollectionParameterReader.IsSupported(methodInfo))
     {
         return null;
     }
     return methodInfo.InParameters;
 }

		public virtual object[] GetInitializers (LogicalMethodInfo[] methodInfos)
		{
			object[] initializers = new object [methodInfos.Length];
			for (int n=0; n<methodInfos.Length; n++)
				initializers [n] = GetInitializer (methodInfos[n]);
				
			return initializers;
		}

 internal static WebServiceAttribute GetAttribute(LogicalMethodInfo[] methodInfos)
 {
     if (methodInfos.Length == 0)
     {
         return new WebServiceAttribute();
     }
     return GetAttribute(GetMostDerivedType(methodInfos));
 }

 public override object GetInitializer(LogicalMethodInfo methodInfo)
 {
     if (!IsSupported(methodInfo))
     {
         return null;
     }
     return methodInfo.InParameters;
 }

 public override object GetInitializer(LogicalMethodInfo methodInfo)
 {
     if (methodInfo.IsVoid)
     {
         return null;
     }
     return this;
 }

 internal static object[] GetInitializers(LogicalMethodInfo methodInfo, SoapReflectedExtension[] extensions)
 {
     object[] objArray = new object[extensions.Length];
     for (int i = 0; i < objArray.Length; i++)
     {
         objArray[i] = extensions[i].GetInitializer(methodInfo);
     }
     return objArray;
 }

 public virtual object[] GetInitializers(LogicalMethodInfo[] methodInfos)
 {
     object[] objArray = new object[methodInfos.Length];
     for (int i = 0; i < objArray.Length; i++)
     {
         objArray[i] = this.GetInitializer(methodInfos[i]);
     }
     return objArray;
 }

 /// <include file='doc\ValueCollectionParameterReader.uex' path='docs/doc[@for="ValueCollectionParameterReader.IsSupported"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 static public bool IsSupported(LogicalMethodInfo methodInfo) {
     if (methodInfo.OutParameters.Length > 0)
         return false;
     ParameterInfo[] paramInfos = methodInfo.InParameters;
     for (int i = 0; i < paramInfos.Length; i++)
         if (!IsSupported(paramInfos[i]))
             return false;
     return true;
 }

 internal HttpClientType(Type type)
 {
     LogicalMethodInfo[] infoArray = LogicalMethodInfo.Create(type.GetMethods(), LogicalMethodTypes.Sync);
     Hashtable formatterTypes = new Hashtable();
     for (int i = 0; i < infoArray.Length; i++)
     {
         LogicalMethodInfo info = infoArray[i];
         try
         {
             object[] customAttributes = info.GetCustomAttributes(typeof(HttpMethodAttribute));
             if (customAttributes.Length != 0)
             {
                 HttpMethodAttribute attribute = (HttpMethodAttribute) customAttributes[0];
                 HttpClientMethod method = new HttpClientMethod {
                     readerType = attribute.ReturnFormatter,
                     writerType = attribute.ParameterFormatter,
                     methodInfo = info
                 };
                 AddFormatter(formatterTypes, method.readerType, method);
                 AddFormatter(formatterTypes, method.writerType, method);
                 this.methods.Add(info.Name, method);
             }
         }
         catch (Exception exception)
         {
             if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
             {
                 throw;
             }
             throw new InvalidOperationException(Res.GetString("WebReflectionError", new object[] { info.DeclaringType.FullName, info.Name }), exception);
         }
     }
     foreach (Type type2 in formatterTypes.Keys)
     {
         ArrayList list = (ArrayList) formatterTypes[type2];
         LogicalMethodInfo[] methodInfos = new LogicalMethodInfo[list.Count];
         for (int j = 0; j < list.Count; j++)
         {
             methodInfos[j] = ((HttpClientMethod) list[j]).methodInfo;
         }
         object[] initializers = MimeFormatter.GetInitializers(type2, methodInfos);
         bool flag = typeof(MimeParameterWriter).IsAssignableFrom(type2);
         for (int k = 0; k < list.Count; k++)
         {
             if (flag)
             {
                 ((HttpClientMethod) list[k]).writerInitializer = initializers[k];
             }
             else
             {
                 ((HttpClientMethod) list[k]).readerInitializer = initializers[k];
             }
         }
     }
 }

 internal DocumentationServerType(Type type, string uri) : base(typeof(DocumentationServerProtocol))
 {
     uri = new Uri(uri, true).GetLeftPart(UriPartial.Path);
     this.methodInfo = new LogicalMethodInfo(typeof(DocumentationServerProtocol).GetMethod("Documentation", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance));
     ServiceDescriptionReflector reflector = new ServiceDescriptionReflector();
     reflector.Reflect(type, uri);
     this.schemas = reflector.Schemas;
     this.serviceDescriptions = reflector.ServiceDescriptions;
     this.schemasWithPost = reflector.SchemasWithPost;
     this.serviceDescriptionsWithPost = reflector.ServiceDescriptionsWithPost;
 }

		public override object GetInitializer (LogicalMethodInfo methodInfo)
		{
			LogicalTypeInfo sti = TypeStubManager.GetLogicalTypeInfo (methodInfo.DeclaringType);
			object[] ats = methodInfo.ReturnTypeCustomAttributeProvider.GetCustomAttributes (typeof(XmlRootAttribute), true);
			XmlRootAttribute root = ats.Length > 0 ? ats[0] as XmlRootAttribute : null; 
			
			XmlReflectionImporter importer = new XmlReflectionImporter ();
			importer.IncludeTypes (methodInfo.CustomAttributeProvider);
			XmlTypeMapping map = importer.ImportTypeMapping (methodInfo.ReturnType, root, sti.GetWebServiceLiteralNamespace (sti.WebServiceNamespace));
			return new XmlSerializer (map);
		}

 private static string GetDefaultAction(string defaultNs, LogicalMethodInfo methodInfo)
 {
     string messageName = methodInfo.MethodAttribute.MessageName;
     if (messageName.Length == 0)
     {
         messageName = methodInfo.Name;
     }
     if (defaultNs.EndsWith("/", StringComparison.Ordinal))
     {
         return (defaultNs + messageName);
     }
     return (defaultNs + "/" + messageName);
 }

        internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos) {
            if (methodInfos.Length == 0) return new object[0];
            WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(methodInfos);
            bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos));
            XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(serviceAttribute.Namespace, serviceDefaultIsEncoded);
            WebMethodReflector.IncludeTypes(methodInfos, importer);
            ArrayList mappings = new ArrayList();
            bool[] supported = new bool[methodInfos.Length];
            for (int i = 0; i < methodInfos.Length; i++) {
                LogicalMethodInfo methodInfo = methodInfos[i];
                Type type = methodInfo.ReturnType;
                if (IsSupported(type) && HttpServerProtocol.AreUrlParametersSupported(methodInfo)) {
                    XmlAttributes a = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
                    XmlTypeMapping mapping = importer.ImportTypeMapping(type, a.XmlRoot);
                    mapping.SetKey(methodInfo.GetKey() + ":Return");
                    mappings.Add(mapping);
                    supported[i] = true;
                }
            }
            if (mappings.Count == 0)
                return new object[0];

            XmlMapping[] xmlMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));
            Evidence evidence = GetEvidenceForType(methodInfos[0].DeclaringType);

            TraceMethod caller = Tracing.On ? new TraceMethod(typeof(XmlReturn), "GetInitializers", methodInfos) : null;
            if (Tracing.On) Tracing.Enter(Tracing.TraceId(Res.TraceCreateSerializer), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", xmlMappings, evidence));
            XmlSerializer[] serializers = null;
            if (AppDomain.CurrentDomain.IsHomogenous)
            {
                serializers = XmlSerializer.FromMappings(xmlMappings);
            }
            else
            {
#pragma warning disable 618 // If we're in a non-homogenous domain, legacy CAS mode is enabled, so passing through evidence will not fail
                serializers = XmlSerializer.FromMappings(xmlMappings, evidence);
#pragma warning restore 618
            }

            if (Tracing.On) Tracing.Exit(Tracing.TraceId(Res.TraceCreateSerializer), caller);

            object[] initializers = new object[methodInfos.Length];
            int count = 0;
            for (int i = 0; i < initializers.Length; i++) {
                if (supported[i]) {
                    initializers[i] = serializers[count++];
                }
            }
            return initializers;
        }