internal static void GenerateXmlMappings(Type type, ArrayList soapMethodList, string serviceNamespace, bool serviceDefaultIsEncoded, ArrayList mappings) { LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(BindingFlags.Public | BindingFlags.Instance), LogicalMethodTypes.Sync); SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded); XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded); WebMethodReflector.IncludeTypes(methodInfos, xmlImporter); SoapReflector.IncludeTypes(methodInfos, soapImporter); for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, true, xmlImporter, soapImporter, serviceNamespace); if (soapMethod == null) { continue; } soapMethodList.Add(soapMethod); mappings.Add(soapMethod.requestMappings); if (soapMethod.responseMappings != null) { mappings.Add(soapMethod.responseMappings); } mappings.Add(soapMethod.inHeaderMappings); if (soapMethod.outHeaderMappings != null) { mappings.Add(soapMethod.outHeaderMappings); } } }
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 HttpClientType(Type type) { LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(), LogicalMethodTypes.Sync); Hashtable formatterTypes = new Hashtable(); for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; try { object[] attributes = methodInfo.GetCustomAttributes(typeof(HttpMethodAttribute)); if (attributes.Length == 0) { continue; } HttpMethodAttribute attribute = (HttpMethodAttribute)attributes[0]; HttpClientMethod method = new HttpClientMethod(); method.readerType = attribute.ReturnFormatter; method.writerType = attribute.ParameterFormatter; method.methodInfo = methodInfo; AddFormatter(formatterTypes, method.readerType, method); AddFormatter(formatterTypes, method.writerType, method); methods.Add(methodInfo.Name, method); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } throw new InvalidOperationException(Res.GetString(Res.WebReflectionError, methodInfo.DeclaringType.FullName, methodInfo.Name), e); } } foreach (Type t in formatterTypes.Keys) { ArrayList list = (ArrayList)formatterTypes[t]; LogicalMethodInfo[] m = new LogicalMethodInfo[list.Count]; for (int j = 0; j < list.Count; j++) { m[j] = ((HttpClientMethod)list[j]).methodInfo; } object[] initializers = MimeFormatter.GetInitializers(t, m); bool isWriter = typeof(MimeParameterWriter).IsAssignableFrom(t); for (int j = 0; j < list.Count; j++) { if (isWriter) { ((HttpClientMethod)list[j]).writerInitializer = initializers[j]; } else { ((HttpClientMethod)list[j]).readerInitializer = initializers[j]; } } } }
internal SoapClientType(Type type) { LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(BindingFlags.Public | BindingFlags.Instance), LogicalMethodTypes.Sync); ArrayList mappings = new ArrayList(); ArrayList soapMethodList = new ArrayList(); this.binding = WebServiceBindingReflector.GetAttribute(type); if (this.binding == null) { throw new InvalidOperationException(Res.GetString(Res.WebClientBindingAttributeRequired)); } // Note: Service namespace is taken from WebserviceBindingAttribute and not WebserviceAttribute because // the generated proxy does not have a WebServiceAttribute; however all have a WebServiceBindingAttribute. serviceNamespace = binding.Namespace; serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type); SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded); XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded); WebMethodReflector.IncludeTypes(methodInfos, xmlImporter); SoapReflector.IncludeTypes(methodInfos, soapImporter); SoapExtensionType[] extensionTypes = WebServicesConfiguration.Current.SoapExtensionTypes; ArrayList highPri = new ArrayList(); ArrayList lowPri = new ArrayList(); for (int i = 0; i < extensionTypes.Length; i++) { SoapReflectedExtension extension = new SoapReflectedExtension(extensionTypes[i].Type, null, extensionTypes[i].Priority); if (extensionTypes[i].Group == SoapExtensionType.PriorityGroup.High) { highPri.Add(extension); } else { lowPri.Add(extension); } } HighPriExtensions = (SoapReflectedExtension[])highPri.ToArray(typeof(SoapReflectedExtension)); LowPriExtensions = (SoapReflectedExtension[])lowPri.ToArray(typeof(SoapReflectedExtension)); Array.Sort(HighPriExtensions); Array.Sort(LowPriExtensions); HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, HighPriExtensions); LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, LowPriExtensions); for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, true, xmlImporter, soapImporter, serviceNamespace); if (soapMethod == null) { continue; } soapMethodList.Add(soapMethod); mappings.Add(soapMethod.requestMappings); if (soapMethod.responseMappings != null) { mappings.Add(soapMethod.responseMappings); } mappings.Add(soapMethod.inHeaderMappings); if (soapMethod.outHeaderMappings != null) { mappings.Add(soapMethod.outHeaderMappings); } } XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping))); int count = 0; for (int i = 0; i < soapMethodList.Count; i++) { SoapReflectedMethod soapMethod = (SoapReflectedMethod)soapMethodList[i]; SoapClientMethod clientMethod = new SoapClientMethod(); clientMethod.parameterSerializer = serializers[count++]; if (soapMethod.responseMappings != null) { clientMethod.returnSerializer = serializers[count++]; } clientMethod.inHeaderSerializer = serializers[count++]; if (soapMethod.outHeaderMappings != null) { clientMethod.outHeaderSerializer = serializers[count++]; } clientMethod.action = soapMethod.action; clientMethod.oneWay = soapMethod.oneWay; clientMethod.rpc = soapMethod.rpc; clientMethod.use = soapMethod.use; clientMethod.paramStyle = soapMethod.paramStyle; clientMethod.methodInfo = soapMethod.methodInfo; clientMethod.extensions = soapMethod.extensions; clientMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(clientMethod.methodInfo, soapMethod.extensions); ArrayList inHeaders = new ArrayList(); ArrayList outHeaders = new ArrayList(); for (int j = 0; j < soapMethod.headers.Length; j++) { SoapHeaderMapping mapping = new SoapHeaderMapping(); SoapReflectedHeader soapHeader = soapMethod.headers[j]; mapping.memberInfo = soapHeader.memberInfo; mapping.repeats = soapHeader.repeats; mapping.custom = soapHeader.custom; mapping.direction = soapHeader.direction; mapping.headerType = soapHeader.headerType; if ((mapping.direction & SoapHeaderDirection.In) != 0) { inHeaders.Add(mapping); } if ((mapping.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0) { outHeaders.Add(mapping); } } clientMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping)); if (clientMethod.outHeaderSerializer != null) { clientMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping)); } methods.Add(soapMethod.name, clientMethod); } }
public LogicalTypeInfo(Type t) { this.Type = t; object [] o = Type.GetCustomAttributes(typeof(WebServiceAttribute), false); if (o.Length == 1) { WebServiceAttribute a = (WebServiceAttribute)o [0]; WebServiceName = (a.Name != string.Empty) ? a.Name : Type.Name; WebServiceNamespace = (a.Namespace != string.Empty) ? a.Namespace : WebServiceAttribute.DefaultNamespace; Description = a.Description; } else { WebServiceName = Type.Name; WebServiceNamespace = WebServiceAttribute.DefaultNamespace; } // Determine the namespaces for literal and encoded schema types bindingUse = SoapBindingUse.Literal; o = t.GetCustomAttributes(typeof(SoapDocumentServiceAttribute), true); if (o.Length > 0) { SoapDocumentServiceAttribute at = (SoapDocumentServiceAttribute)o[0]; bindingUse = at.Use; if (bindingUse == SoapBindingUse.Default) { bindingUse = SoapBindingUse.Literal; } routingStyle = at.RoutingStyle; } else if (t.GetCustomAttributes(typeof(SoapRpcServiceAttribute), true).Length > 0) { o = t.GetCustomAttributes(typeof(SoapRpcServiceAttribute), true); SoapRpcServiceAttribute at = (SoapRpcServiceAttribute)o[0]; #if NET_2_0 bindingUse = at.Use; #else bindingUse = SoapBindingUse.Encoded; #endif routingStyle = at.RoutingStyle; if (bindingUse == SoapBindingUse.Default) { bindingUse = SoapBindingUse.Encoded; } } else { routingStyle = SoapServiceRoutingStyle.SoapAction; } string sep = WebServiceNamespace.EndsWith("/") ? "" : "/"; WebServiceAbstractNamespace = WebServiceNamespace + sep + "AbstractTypes"; #if NET_2_0 MethodInfo [] type_methods; if (typeof(WebClientProtocol).IsAssignableFrom(Type)) { type_methods = Type.GetMethods(BindingFlags.Instance | BindingFlags.Public); } else { MethodInfo [] all_type_methods = Type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); ArrayList list = new ArrayList(all_type_methods.Length); foreach (MethodInfo mi in all_type_methods) { if (mi.IsPublic && mi.GetCustomAttributes(typeof(WebMethodAttribute), false).Length > 0) { list.Add(mi); } else { foreach (Type ifaceType in Type.GetInterfaces()) { if (ifaceType.GetCustomAttributes(typeof(WebServiceBindingAttribute), false).Length > 0) { MethodInfo found = FindInInterface(ifaceType, mi); if (found != null) { if (found.GetCustomAttributes(typeof(WebMethodAttribute), false).Length > 0) { list.Add(found); } break; } } } } } type_methods = (MethodInfo [])list.ToArray(typeof(MethodInfo)); } #else MethodInfo [] type_methods = Type.GetMethods(BindingFlags.Instance | BindingFlags.Public); #endif logicalMethods = LogicalMethodInfo.Create(type_methods, LogicalMethodTypes.Sync); }