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); }
private void ReflectInternal(ProtocolReflector[] reflectors) { this.description = new System.Web.Services.Description.ServiceDescription(); this.description.TargetNamespace = this.serviceAttr.Namespace; this.ServiceDescriptions.Add(this.description); this.service = new System.Web.Services.Description.Service(); string name = this.serviceAttr.Name; if ((name == null) || (name.Length == 0)) { name = this.serviceType.Name; } this.service.Name = XmlConvert.EncodeLocalName(name); if ((this.serviceAttr.Description != null) && (this.serviceAttr.Description.Length > 0)) { this.service.Documentation = this.serviceAttr.Description; } this.description.Services.Add(this.service); this.reflectionContext = new Hashtable(); this.exporter = new XmlSchemaExporter(this.description.Types.Schemas); this.importer = SoapReflector.CreateXmlImporter(this.serviceAttr.Namespace, SoapReflector.ServiceDefaultIsEncoded(this.serviceType)); WebMethodReflector.IncludeTypes(this.methods, this.importer); for (int i = 0; i < reflectors.Length; i++) { reflectors[i].Reflect(); } }
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); } } }
private void ReflectInternal(ProtocolReflector[] reflectors) { description = new ServiceDescription(); description.TargetNamespace = serviceAttr.Namespace; ServiceDescriptions.Add(description); service = new Service(); string name = serviceAttr.Name; if (name == null || name.Length == 0) { name = serviceType.Name; } service.Name = XmlConvert.EncodeLocalName(name); if (serviceAttr.Description != null && serviceAttr.Description.Length > 0) { service.Documentation = serviceAttr.Description; } description.Services.Add(service); reflectionContext = new Hashtable(); exporter = new XmlSchemaExporter(description.Types.Schemas); importer = SoapReflector.CreateXmlImporter(serviceAttr.Namespace, SoapReflector.ServiceDefaultIsEncoded(serviceType)); WebMethodReflector.IncludeTypes(methods, importer); for (int i = 0; i < reflectors.Length; i++) { reflectors[i].Reflect(); } }
protected override bool ReflectMethod() { soapMethod = ReflectionContext[Method] as SoapReflectedMethod; if (soapMethod == null) { soapMethod = SoapReflector.ReflectMethod(Method, false, ReflectionImporter, SoapImporter, DefaultNamespace); ReflectionContext[Method] = soapMethod; soapMethod.portType = Binding != null ? Binding.Type : null; } WebMethodAttribute methodAttr = WebMethodReflector.GetAttribute(Method); OperationBinding.Extensions.Add(CreateSoapOperationBinding(soapMethod.rpc ? SoapBindingStyle.Rpc : SoapBindingStyle.Document, soapMethod.action)); CreateMessage(soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, InputMessage, OperationBinding.Input, soapMethod.requestMappings); if (!soapMethod.oneWay) { CreateMessage(soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, OutputMessage, OperationBinding.Output, soapMethod.responseMappings); } CreateHeaderMessages(soapMethod.name, soapMethod.use, soapMethod.inHeaderMappings, soapMethod.outHeaderMappings, soapMethod.headers); if (soapMethod.rpc && soapMethod.methodInfo.OutParameters.Length > 0) { Operation.ParameterOrder = GetParameterOrder(soapMethod.methodInfo); } AllowExtensionsToReflectMethod(); return(true); }
/// <include file='doc\ServiceDescriptionReflector.uex' path='docs/doc[@for="ServiceDescriptionReflector.Reflect"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Reflect(Type type, string url) { serviceType = type; serviceUrl = url; serviceAttr = WebServiceReflector.GetAttribute(type); methods = WebMethodReflector.GetMethods(type); CheckForDuplicateMethods(methods); descriptionsWithPost = descriptions; schemasWithPost = schemas; if (reflectorsWithPost != null) { ReflectInternal(reflectorsWithPost); descriptions = new ServiceDescriptionCollection(); schemas = new XmlSchemas(); } ReflectInternal(reflectors); if (serviceAttr.Description != null && serviceAttr.Description.Length > 0) { ServiceDescription.Documentation = serviceAttr.Description; } // need to preprocess all exported schemas to make sure that IXmlSerializable schemas are Merged and the resulting set is valid ServiceDescription.Types.Schemas.Compile(null, false); if (ServiceDescriptions.Count > 1) { // if defining interfaces, we move all schemas to the external collection // since the types therein may be referenced from any of the sdls Schemas.Add(ServiceDescription.Types.Schemas); ServiceDescription.Types.Schemas.Clear(); } else if (ServiceDescription.Types.Schemas.Count > 0) { XmlSchema[] descriptionSchemas = new XmlSchema[ServiceDescription.Types.Schemas.Count]; ServiceDescription.Types.Schemas.CopyTo(descriptionSchemas, 0); foreach (XmlSchema schema in descriptionSchemas) { // we always move dataset schemas to the external schema's collection. if (XmlSchemas.IsDataSet(schema)) { ServiceDescription.Types.Schemas.Remove(schema); Schemas.Add(schema); } } } }
static string GetDefaultAction(string defaultNs, LogicalMethodInfo methodInfo) { WebMethodAttribute methodAttribute = WebMethodReflector.GetAttribute(methodInfo); string messageName = methodAttribute.MessageName; if (messageName.Length == 0) { messageName = methodInfo.Name; } if (defaultNs.EndsWith("/")) { return(defaultNs + messageName); } return(defaultNs + "/" + messageName); }
public SoapServerMethod(Type serverType, LogicalMethodInfo methodInfo) { this.methodInfo = methodInfo; string defaultNs = WebServiceReflector.GetAttribute(serverType).Namespace; bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(serverType); SoapReflectionImporter importer = SoapReflector.CreateSoapImporter(defaultNs, serviceDefaultIsEncoded); XmlReflectionImporter importer2 = SoapReflector.CreateXmlImporter(defaultNs, serviceDefaultIsEncoded); SoapReflector.IncludeTypes(methodInfo, importer); WebMethodReflector.IncludeTypes(methodInfo, importer2); SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, false, importer2, importer, defaultNs); this.ImportReflectedMethod(soapMethod); this.ImportSerializers(soapMethod, this.GetServerTypeEvidence(serverType)); this.ImportHeaderSerializers(soapMethod); }
void CheckForDuplicateMethods(LogicalMethodInfo[] methods) { Hashtable messageNames = new Hashtable(); foreach (LogicalMethodInfo method in methods) { WebMethodAttribute attribute = WebMethodReflector.GetAttribute(method); string messageName = attribute.MessageName; if (messageName.Length == 0) { messageName = method.Name; } LogicalMethodInfo existingMethod = (LogicalMethodInfo)messageNames[messageName]; if (existingMethod != null) { throw new InvalidOperationException(Res.GetString(Res.BothAndUseTheMessageNameUseTheMessageName3, method, existingMethod, messageName)); } messageNames.Add(messageName, method); } }
public void Reflect(Type type, string url) { this.serviceType = type; this.serviceUrl = url; this.serviceAttr = WebServiceReflector.GetAttribute(type); this.methods = WebMethodReflector.GetMethods(type); this.CheckForDuplicateMethods(this.methods); this.descriptionsWithPost = this.descriptions; this.schemasWithPost = this.schemas; if (this.reflectorsWithPost != null) { this.ReflectInternal(this.reflectorsWithPost); this.descriptions = new ServiceDescriptionCollection(); this.schemas = new XmlSchemas(); } this.ReflectInternal(this.reflectors); if ((this.serviceAttr.Description != null) && (this.serviceAttr.Description.Length > 0)) { this.ServiceDescription.Documentation = this.serviceAttr.Description; } this.ServiceDescription.Types.Schemas.Compile(null, false); if (this.ServiceDescriptions.Count > 1) { this.Schemas.Add(this.ServiceDescription.Types.Schemas); this.ServiceDescription.Types.Schemas.Clear(); } else if (this.ServiceDescription.Types.Schemas.Count > 0) { XmlSchema[] array = new XmlSchema[this.ServiceDescription.Types.Schemas.Count]; this.ServiceDescription.Types.Schemas.CopyTo(array, 0); foreach (XmlSchema schema in array) { if (XmlSchemas.IsDataSet(schema)) { this.ServiceDescription.Types.Schemas.Remove(schema); this.Schemas.Add(schema); } } } }
/// <include file='doc\ServiceDescriptionReflector.uex' path='docs/doc[@for="ServiceDescriptionReflector.Reflect"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Reflect(Type type, string url) { serviceType = type; serviceUrl = url; serviceAttr = WebServiceReflector.GetAttribute(type); methods = WebMethodReflector.GetMethods(type); CheckForDuplicateMethods(methods); descriptionsWithPost = descriptions; schemasWithPost = schemas; if (reflectorsWithPost != null) { ReflectInternal(reflectorsWithPost); descriptions = new ServiceDescriptionCollection(); schemas = new XmlSchemas(); } ReflectInternal(reflectors); XmlSchema[] descriptionSchemas = new XmlSchema[ServiceDescription.Types.Schemas.Count]; ServiceDescription.Types.Schemas.CopyTo(descriptionSchemas, 0); // if defining interfaces, we move all schemas to the external collection // since the types therein may be referenced from any of the sdls bool externalizeSchemas = ServiceDescriptions.Count > 1; foreach (XmlSchema schema in descriptionSchemas) { // we always move dataset schemas to the external schema's collection. if (externalizeSchemas || XmlSchemas.IsDataSet(schema)) { ServiceDescription.Types.Schemas.Remove(schema); Schemas.Add(schema); } } }
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(); for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; Type type = methodInfo.ReturnType; if (IsSupported(type)) { XmlAttributes a = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); XmlTypeMapping mapping = importer.ImportTypeMapping(type, a.XmlRoot); mappings.Add(mapping); } } XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping))); object[] initializers = new object[methodInfos.Length]; int count = 0; for (int i = 0; i < initializers.Length; i++) { if (IsSupported(methodInfos[i].ReturnType)) { initializers[i] = serializers[count++]; } } return(initializers); }
internal SoapServerType(Type type, ProtocolsEnum versionsSupported) : base(type) { this.versionsSupported = versionsSupported; bool soap11 = (versionsSupported & ProtocolsEnum.HttpSoap) != 0; bool soap12 = (versionsSupported & ProtocolsEnum.HttpSoap12) != 0; LogicalMethodInfo[] methodInfos = WebMethodReflector.GetMethods(type); ArrayList mappings = new ArrayList(); WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(type); object soapServiceAttribute = SoapReflector.GetSoapServiceAttribute(type); routingOnSoapAction = SoapReflector.GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.SoapAction; serviceNamespace = serviceAttribute.Namespace; serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type); SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded); XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded); SoapReflector.IncludeTypes(methodInfos, soapImporter); WebMethodReflector.IncludeTypes(methodInfos, xmlImporter); SoapReflectedMethod[] soapMethods = new SoapReflectedMethod[methodInfos.Length]; 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, false, xmlImporter, soapImporter, serviceAttribute.Namespace); mappings.Add(soapMethod.requestMappings); if (soapMethod.responseMappings != null) { mappings.Add(soapMethod.responseMappings); } mappings.Add(soapMethod.inHeaderMappings); if (soapMethod.outHeaderMappings != null) { mappings.Add(soapMethod.outHeaderMappings); } soapMethods[i] = soapMethod; } XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping))); int count = 0; for (int i = 0; i < soapMethods.Length; i++) { SoapServerMethod serverMethod = new SoapServerMethod(); SoapReflectedMethod soapMethod = soapMethods[i]; serverMethod.parameterSerializer = serializers[count++]; if (soapMethod.responseMappings != null) { serverMethod.returnSerializer = serializers[count++]; } serverMethod.inHeaderSerializer = serializers[count++]; if (soapMethod.outHeaderMappings != null) { serverMethod.outHeaderSerializer = serializers[count++]; } serverMethod.methodInfo = soapMethod.methodInfo; serverMethod.action = soapMethod.action; serverMethod.extensions = soapMethod.extensions; serverMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(serverMethod.methodInfo, soapMethod.extensions); serverMethod.oneWay = soapMethod.oneWay; serverMethod.rpc = soapMethod.rpc; serverMethod.use = soapMethod.use; serverMethod.paramStyle = soapMethod.paramStyle; 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) { inHeaders.Add(mapping); } else if (mapping.direction == SoapHeaderDirection.Out) { outHeaders.Add(mapping); } else { inHeaders.Add(mapping); outHeaders.Add(mapping); } } serverMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping)); if (serverMethod.outHeaderSerializer != null) { serverMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping)); } // check feasibility of routing on request element for soap 1.1 if (soap11 && !routingOnSoapAction && soapMethod.requestElementName.IsEmpty) { throw new SoapException(Res.GetString(Res.TheMethodDoesNotHaveARequestElementEither1, serverMethod.methodInfo.Name), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace)); } // we can lookup methods by action or request element if (methods[soapMethod.action] == null) { methods[soapMethod.action] = serverMethod; } else { // duplicate soap actions not allowed in soap 1.1 if we're routing on soap action if (soap11 && routingOnSoapAction) { SoapServerMethod duplicateMethod = (SoapServerMethod)methods[soapMethod.action]; throw new SoapException(Res.GetString(Res.TheMethodsAndUseTheSameSoapActionWhenTheService3, serverMethod.methodInfo.Name, duplicateMethod.methodInfo.Name, soapMethod.action), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace)); } duplicateMethods[soapMethod.action] = serverMethod; } if (methods[soapMethod.requestElementName] == null) { methods[soapMethod.requestElementName] = serverMethod; } else { // duplicate request elements not allowed in soap 1.1 if we're routing on request element if (soap11 && !routingOnSoapAction) { SoapServerMethod duplicateMethod = (SoapServerMethod)methods[soapMethod.requestElementName]; throw new SoapException(Res.GetString(Res.TheMethodsAndUseTheSameRequestElementXmlns4, serverMethod.methodInfo.Name, duplicateMethod.methodInfo.Name, soapMethod.requestElementName.Name, soapMethod.requestElementName.Namespace), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace)); } duplicateMethods[soapMethod.requestElementName] = serverMethod; } } }
internal HttpServerType(Type type) : base(type) { this.methods = new Hashtable(); WebServicesSection current = WebServicesSection.Current; Type[] returnWriterTypes = current.ReturnWriterTypes; Type[] parameterReaderTypes = current.ParameterReaderTypes; LogicalMethodInfo[] methods = WebMethodReflector.GetMethods(type); HttpServerMethod[] methodArray = new HttpServerMethod[methods.Length]; object[] objArray = new object[returnWriterTypes.Length]; for (int i = 0; i < objArray.Length; i++) { objArray[i] = MimeFormatter.GetInitializers(returnWriterTypes[i], methods); } for (int j = 0; j < methods.Length; j++) { LogicalMethodInfo info = methods[j]; HttpServerMethod method = null; if (info.ReturnType == typeof(void)) { method = new HttpServerMethod(); } else { for (int num3 = 0; num3 < returnWriterTypes.Length; num3++) { object[] objArray2 = (object[])objArray[num3]; if (objArray2[j] != null) { method = new HttpServerMethod { writerInitializer = objArray2[j], writerType = returnWriterTypes[num3] }; break; } } } if (method != null) { method.methodInfo = info; methodArray[j] = method; } } objArray = new object[parameterReaderTypes.Length]; for (int k = 0; k < objArray.Length; k++) { objArray[k] = MimeFormatter.GetInitializers(parameterReaderTypes[k], methods); } for (int m = 0; m < methods.Length; m++) { HttpServerMethod method2 = methodArray[m]; if (method2 != null) { LogicalMethodInfo info2 = methods[m]; if (info2.InParameters.Length > 0) { int index = 0; for (int num7 = 0; num7 < parameterReaderTypes.Length; num7++) { object[] objArray3 = (object[])objArray[num7]; if (objArray3[m] != null) { index++; } } if (index == 0) { methodArray[m] = null; } else { method2.readerTypes = new Type[index]; method2.readerInitializers = new object[index]; index = 0; for (int num8 = 0; num8 < parameterReaderTypes.Length; num8++) { object[] objArray4 = (object[])objArray[num8]; if (objArray4[m] != null) { method2.readerTypes[index] = parameterReaderTypes[num8]; method2.readerInitializers[index] = objArray4[m]; index++; } } } } } } for (int n = 0; n < methodArray.Length; n++) { HttpServerMethod method3 = methodArray[n]; if (method3 != null) { WebMethodAttribute methodAttribute = method3.methodInfo.MethodAttribute; method3.name = methodAttribute.MessageName; if (method3.name.Length == 0) { method3.name = method3.methodInfo.Name; } this.methods.Add(method3.name, method3); } } }
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); }
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 SoapServerType(Type type, WebServiceProtocols protocolsSupported) : base(type) { this.methods = new Hashtable(); this.duplicateMethods = new Hashtable(); this.protocolsSupported = protocolsSupported; bool flag = (protocolsSupported & WebServiceProtocols.HttpSoap) != WebServiceProtocols.Unknown; LogicalMethodInfo[] methods = WebMethodReflector.GetMethods(type); ArrayList list = new ArrayList(); WebServiceAttribute attribute = WebServiceReflector.GetAttribute(type); object soapServiceAttribute = SoapReflector.GetSoapServiceAttribute(type); this.routingOnSoapAction = SoapReflector.GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.SoapAction; this.serviceNamespace = attribute.Namespace; this.serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type); SoapReflectionImporter importer = SoapReflector.CreateSoapImporter(this.serviceNamespace, this.serviceDefaultIsEncoded); XmlReflectionImporter importer2 = SoapReflector.CreateXmlImporter(this.serviceNamespace, this.serviceDefaultIsEncoded); SoapReflector.IncludeTypes(methods, importer); WebMethodReflector.IncludeTypes(methods, importer2); SoapReflectedMethod[] methodArray = new SoapReflectedMethod[methods.Length]; SoapExtensionTypeElementCollection soapExtensionTypes = WebServicesSection.Current.SoapExtensionTypes; ArrayList list2 = new ArrayList(); ArrayList list3 = new ArrayList(); for (int i = 0; i < soapExtensionTypes.Count; i++) { SoapExtensionTypeElement element = soapExtensionTypes[i]; if (element != null) { SoapReflectedExtension extension = new SoapReflectedExtension(element.Type, null, element.Priority); if (element.Group == PriorityGroup.High) { list2.Add(extension); } else { list3.Add(extension); } } } this.HighPriExtensions = (SoapReflectedExtension[])list2.ToArray(typeof(SoapReflectedExtension)); this.LowPriExtensions = (SoapReflectedExtension[])list3.ToArray(typeof(SoapReflectedExtension)); Array.Sort <SoapReflectedExtension>(this.HighPriExtensions); Array.Sort <SoapReflectedExtension>(this.LowPriExtensions); this.HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.HighPriExtensions); this.LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.LowPriExtensions); for (int j = 0; j < methods.Length; j++) { LogicalMethodInfo methodInfo = methods[j]; SoapReflectedMethod method = SoapReflector.ReflectMethod(methodInfo, false, importer2, importer, attribute.Namespace); list.Add(method.requestMappings); if (method.responseMappings != null) { list.Add(method.responseMappings); } list.Add(method.inHeaderMappings); if (method.outHeaderMappings != null) { list.Add(method.outHeaderMappings); } methodArray[j] = method; } XmlMapping[] mappings = (XmlMapping[])list.ToArray(typeof(XmlMapping)); TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", new object[] { type, protocolsSupported }) : null; if (Tracing.On) { Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappings, base.Evidence })); } XmlSerializer[] serializerArray = null; if (AppDomain.CurrentDomain.IsHomogenous) { serializerArray = XmlSerializer.FromMappings(mappings); } else { serializerArray = XmlSerializer.FromMappings(mappings, base.Evidence); } if (Tracing.On) { Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller); } int num3 = 0; for (int k = 0; k < methodArray.Length; k++) { SoapServerMethod method3 = new SoapServerMethod(); SoapReflectedMethod method4 = methodArray[k]; method3.parameterSerializer = serializerArray[num3++]; if (method4.responseMappings != null) { method3.returnSerializer = serializerArray[num3++]; } method3.inHeaderSerializer = serializerArray[num3++]; if (method4.outHeaderMappings != null) { method3.outHeaderSerializer = serializerArray[num3++]; } method3.methodInfo = method4.methodInfo; method3.action = method4.action; method3.extensions = method4.extensions; method3.extensionInitializers = SoapReflectedExtension.GetInitializers(method3.methodInfo, method4.extensions); method3.oneWay = method4.oneWay; method3.rpc = method4.rpc; method3.use = method4.use; method3.paramStyle = method4.paramStyle; method3.wsiClaims = (method4.binding == null) ? WsiProfiles.None : method4.binding.ConformsTo; ArrayList list4 = new ArrayList(); ArrayList list5 = new ArrayList(); for (int m = 0; m < method4.headers.Length; m++) { SoapHeaderMapping mapping = new SoapHeaderMapping(); SoapReflectedHeader header = method4.headers[m]; mapping.memberInfo = header.memberInfo; mapping.repeats = header.repeats; mapping.custom = header.custom; mapping.direction = header.direction; mapping.headerType = header.headerType; if (mapping.direction == SoapHeaderDirection.In) { list4.Add(mapping); } else if (mapping.direction == SoapHeaderDirection.Out) { list5.Add(mapping); } else { list4.Add(mapping); list5.Add(mapping); } } method3.inHeaderMappings = (SoapHeaderMapping[])list4.ToArray(typeof(SoapHeaderMapping)); if (method3.outHeaderSerializer != null) { method3.outHeaderMappings = (SoapHeaderMapping[])list5.ToArray(typeof(SoapHeaderMapping)); } if ((flag && !this.routingOnSoapAction) && method4.requestElementName.IsEmpty) { throw new SoapException(System.Web.Services.Res.GetString("TheMethodDoesNotHaveARequestElementEither1", new object[] { method3.methodInfo.Name }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/")); } if (this.methods[method4.action] == null) { this.methods[method4.action] = method3; } else { if (flag && this.routingOnSoapAction) { SoapServerMethod method5 = (SoapServerMethod)this.methods[method4.action]; throw new SoapException(System.Web.Services.Res.GetString("TheMethodsAndUseTheSameSoapActionWhenTheService3", new object[] { method3.methodInfo.Name, method5.methodInfo.Name, method4.action }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/")); } this.duplicateMethods[method4.action] = method3; } if (this.methods[method4.requestElementName] == null) { this.methods[method4.requestElementName] = method3; } else { if (flag && !this.routingOnSoapAction) { SoapServerMethod method6 = (SoapServerMethod)this.methods[method4.requestElementName]; throw new SoapException(System.Web.Services.Res.GetString("TheMethodsAndUseTheSameRequestElementXmlns4", new object[] { method3.methodInfo.Name, method6.methodInfo.Name, method4.requestElementName.Name, method4.requestElementName.Namespace }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/")); } this.duplicateMethods[method4.requestElementName] = method3; } } }
internal HttpServerType(Type type) : base(type) { WebServicesSection config = WebServicesSection.Current; Type[] returnWriterTypes = config.ReturnWriterTypes; Type[] parameterReaderTypes = config.ParameterReaderTypes; LogicalMethodInfo[] methodInfos = WebMethodReflector.GetMethods(type); HttpServerMethod[] methods = new HttpServerMethod[methodInfos.Length]; object[] initializersByType = new object[returnWriterTypes.Length]; for (int i = 0; i < initializersByType.Length; i++) { initializersByType[i] = MimeFormatter.GetInitializers(returnWriterTypes[i], methodInfos); } for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; HttpServerMethod method = null; if (methodInfo.ReturnType == typeof(void)) { method = new HttpServerMethod(); } else { for (int j = 0; j < returnWriterTypes.Length; j++) { object[] initializers = (object[])initializersByType[j]; if (initializers[i] != null) { method = new HttpServerMethod(); method.writerInitializer = initializers[i]; method.writerType = returnWriterTypes[j]; break; } } } if (method != null) { method.methodInfo = methodInfo; methods[i] = method; } } initializersByType = new object[parameterReaderTypes.Length]; for (int i = 0; i < initializersByType.Length; i++) { initializersByType[i] = MimeFormatter.GetInitializers(parameterReaderTypes[i], methodInfos); } for (int i = 0; i < methodInfos.Length; i++) { HttpServerMethod method = methods[i]; if (method == null) { continue; } LogicalMethodInfo methodInfo = methodInfos[i]; if (methodInfo.InParameters.Length > 0) { int count = 0; for (int j = 0; j < parameterReaderTypes.Length; j++) { object[] initializers = (object[])initializersByType[j]; if (initializers[i] != null) { count++; } } if (count == 0) { methods[i] = null; } else { method.readerTypes = new Type[count]; method.readerInitializers = new object[count]; count = 0; for (int j = 0; j < parameterReaderTypes.Length; j++) { object[] initializers = (object[])initializersByType[j]; if (initializers[i] != null) { method.readerTypes[count] = parameterReaderTypes[j]; method.readerInitializers[count] = initializers[i]; count++; } } } } } for (int i = 0; i < methods.Length; i++) { HttpServerMethod method = methods[i]; if (method != null) { WebMethodAttribute methodAttribute = method.methodInfo.MethodAttribute; method.name = methodAttribute.MessageName; if (method.name.Length == 0) { method.name = method.methodInfo.Name; } this.methods.Add(method.name, method); } } }
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); }
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); } }
void MoveToMethod(LogicalMethodInfo method) { this.method = method; this.methodAttr = WebMethodReflector.GetAttribute(method); }