internal static void IncludeTypes(LogicalMethodInfo[] methods, XmlReflectionImporter importer) { for (int i = 0; i < methods.Length; i++) { LogicalMethodInfo method = methods[i]; importer.IncludeTypes(method.DeclaringType); importer.IncludeTypes(method.CustomAttributeProvider); } }
internal static void IncludeTypes(LogicalMethodInfo method, XmlReflectionImporter importer) { if (method.Declaration != null) { importer.IncludeTypes(method.Declaration.DeclaringType); importer.IncludeTypes(method.Declaration); } importer.IncludeTypes(method.DeclaringType); importer.IncludeTypes(method.CustomAttributeProvider); }
public SoapTypeStubInfo(LogicalTypeInfo logicalTypeInfo) : base(logicalTypeInfo) { xmlImporter = new XmlReflectionImporter(); soapImporter = new SoapReflectionImporter(); if (typeof(SoapHttpClientProtocol).IsAssignableFrom(Type)) { if (Bindings.Count == 0 || ((BindingInfo)Bindings[0]).WebServiceBindingAttribute == null) { throw new InvalidOperationException("WebServiceBindingAttribute is required on proxy class '" + Type + "'."); } if (Bindings.Count > 1) { throw new InvalidOperationException("Only one WebServiceBinding attribute may be specified on type '" + Type + "'."); } } object [] o = Type.GetCustomAttributes(typeof(SoapDocumentServiceAttribute), false); if (o.Length == 1) { SoapDocumentServiceAttribute a = (SoapDocumentServiceAttribute)o [0]; ParameterStyle = a.ParameterStyle; SoapBindingStyle = SoapBindingStyle.Document; } else { o = Type.GetCustomAttributes(typeof(SoapRpcServiceAttribute), false); if (o.Length == 1) { SoapRpcServiceAttribute srs = (SoapRpcServiceAttribute)o [0]; ParameterStyle = SoapParameterStyle.Wrapped; SoapBindingStyle = SoapBindingStyle.Rpc; } else { ParameterStyle = SoapParameterStyle.Wrapped; SoapBindingStyle = SoapBindingStyle.Document; } } if (ParameterStyle == SoapParameterStyle.Default) { ParameterStyle = SoapParameterStyle.Wrapped; } xmlImporter.IncludeTypes(Type); soapImporter.IncludeTypes(Type); #if MONOTOUCH SoapExtensions = new SoapExtensionRuntimeConfig [2][]; #else SoapExtensions = SoapExtension.GetTypeExtensions(Type); #endif }
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)); }
public override object[] GetInitializers(LogicalMethodInfo[] methodInfos) { XmlReflectionImporter importer = new XmlReflectionImporter(); XmlMapping[] sers = new XmlMapping [methodInfos.Length]; for (int n = 0; n < sers.Length; n++) { LogicalMethodInfo metinfo = methodInfos[n]; if (metinfo.IsVoid) { sers[n] = null; } else { importer.IncludeTypes(metinfo.CustomAttributeProvider); LogicalTypeInfo sti = TypeStubManager.GetLogicalTypeInfo(metinfo.DeclaringType); object[] ats = methodInfos[n].ReturnTypeCustomAttributeProvider.GetCustomAttributes(typeof(XmlRootAttribute), true); XmlRootAttribute root = ats.Length > 0 ? ats[0] as XmlRootAttribute : null; sers[n] = importer.ImportTypeMapping(methodInfos[n].ReturnType, root, sti.GetWebServiceLiteralNamespace(sti.WebServiceNamespace)); } } return(XmlSerializer.FromMappings(sers)); }
// // Constructor // public SoapMethodStubInfo(TypeStubInfo typeStub, LogicalMethodInfo source, object kind, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter) : base(typeStub, source) { SoapTypeStubInfo parent = (SoapTypeStubInfo)typeStub; XmlElementAttribute optional_ns = null; if (kind == null) { Use = parent.LogicalType.BindingUse; RequestName = ""; RequestNamespace = ""; ResponseName = ""; ResponseNamespace = ""; ParameterStyle = parent.ParameterStyle; SoapBindingStyle = parent.SoapBindingStyle; OneWay = false; // disabled (see bug #332150) //#if NET_2_0 // if (parent.Type != source.DeclaringType) // Binding = source.DeclaringType.Name + parent.ProtocolName; //#endif } else if (kind is SoapDocumentMethodAttribute) { SoapDocumentMethodAttribute dma = (SoapDocumentMethodAttribute)kind; Use = dma.Use; if (Use == SoapBindingUse.Default) { if (parent.SoapBindingStyle == SoapBindingStyle.Document) { Use = parent.LogicalType.BindingUse; } else { Use = SoapBindingUse.Literal; } } Action = dma.Action; Binding = dma.Binding; RequestName = dma.RequestElementName; RequestNamespace = dma.RequestNamespace; ResponseName = dma.ResponseElementName; ResponseNamespace = dma.ResponseNamespace; ParameterStyle = dma.ParameterStyle; if (ParameterStyle == SoapParameterStyle.Default) { ParameterStyle = parent.ParameterStyle; } OneWay = dma.OneWay; SoapBindingStyle = SoapBindingStyle.Document; } else { SoapRpcMethodAttribute rma = (SoapRpcMethodAttribute)kind; Use = SoapBindingUse.Encoded; // RPC always use encoded Action = rma.Action; if (Action != null && Action.Length == 0) { Action = null; } Binding = rma.Binding; // When using RPC, MS.NET seems to ignore RequestElementName and // MessageName, and it always uses the method name RequestName = source.Name; ResponseName = source.Name + "Response"; // RequestName = rma.RequestElementName; // ResponseName = rma.ResponseElementName; RequestNamespace = rma.RequestNamespace; ResponseNamespace = rma.ResponseNamespace; ParameterStyle = SoapParameterStyle.Wrapped; OneWay = rma.OneWay; SoapBindingStyle = SoapBindingStyle.Rpc; // For RPC calls, make all arguments be part of the empty namespace optional_ns = new XmlElementAttribute(); optional_ns.Namespace = ""; } if (OneWay) { if (source.ReturnType != typeof(void)) { throw new Exception("OneWay methods should not have a return value."); } if (source.OutParameters.Length != 0) { throw new Exception("OneWay methods should not have out/ref parameters."); } } BindingInfo binfo = parent.GetBinding(Binding); if (binfo == null) { throw new InvalidOperationException("Type '" + parent.Type + "' is missing WebServiceBinding attribute that defines a binding named '" + Binding + "'."); } string serviceNamespace = binfo.Namespace; if (RequestNamespace == "") { RequestNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use); } if (ResponseNamespace == "") { ResponseNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use); } if (RequestName == "") { RequestName = Name; } if (ResponseName == "") { ResponseName = Name + "Response"; } if (Action == null) { Action = serviceNamespace.EndsWith("/") ? (serviceNamespace + Name) : (serviceNamespace + "/" + Name); } bool hasWrappingElem = (ParameterStyle == SoapParameterStyle.Wrapped); bool writeAccessors = (SoapBindingStyle == SoapBindingStyle.Rpc); XmlReflectionMember [] in_members = BuildRequestReflectionMembers(optional_ns); XmlReflectionMember [] out_members = BuildResponseReflectionMembers(optional_ns); if (Use == SoapBindingUse.Literal) { xmlImporter.IncludeTypes(source.CustomAttributeProvider); InputMembersMapping = xmlImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem); OutputMembersMapping = xmlImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem); } else { soapImporter.IncludeTypes(source.CustomAttributeProvider); InputMembersMapping = soapImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem, writeAccessors); OutputMembersMapping = soapImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem, writeAccessors); } requestSerializerId = parent.RegisterSerializer(InputMembersMapping); responseSerializerId = parent.RegisterSerializer(OutputMembersMapping); object[] o = source.GetCustomAttributes(typeof(SoapHeaderAttribute)); ArrayList allHeaderList = new ArrayList(o.Length); ArrayList inHeaderList = new ArrayList(o.Length); ArrayList outHeaderList = new ArrayList(o.Length); ArrayList faultHeaderList = new ArrayList(); SoapHeaderDirection unknownHeaderDirections = (SoapHeaderDirection)0; for (int i = 0; i < o.Length; i++) { SoapHeaderAttribute att = (SoapHeaderAttribute)o[i]; MemberInfo[] mems = source.DeclaringType.GetMember(att.MemberName); if (mems.Length == 0) { throw new InvalidOperationException("Member " + att.MemberName + " not found in class " + source.DeclaringType.FullName + "."); } HeaderInfo header = new HeaderInfo(mems[0], att); allHeaderList.Add(header); if (!header.Custom) { if ((header.Direction & SoapHeaderDirection.In) != 0) { inHeaderList.Add(header); } if ((header.Direction & SoapHeaderDirection.Out) != 0) { outHeaderList.Add(header); } if ((header.Direction & SoapHeaderDirection.Fault) != 0) { faultHeaderList.Add(header); } } else { unknownHeaderDirections |= header.Direction; } } Headers = (HeaderInfo[])allHeaderList.ToArray(typeof(HeaderInfo)); if (inHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.In) != 0) { InHeaders = (HeaderInfo[])inHeaderList.ToArray(typeof(HeaderInfo)); XmlReflectionMember[] members = BuildHeadersReflectionMembers(InHeaders); if (Use == SoapBindingUse.Literal) { InputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false); } else { InputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false); } requestHeadersSerializerId = parent.RegisterSerializer(InputHeaderMembersMapping); } if (outHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Out) != 0) { OutHeaders = (HeaderInfo[])outHeaderList.ToArray(typeof(HeaderInfo)); XmlReflectionMember[] members = BuildHeadersReflectionMembers(OutHeaders); if (Use == SoapBindingUse.Literal) { OutputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false); } else { OutputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false); } responseHeadersSerializerId = parent.RegisterSerializer(OutputHeaderMembersMapping); } if (faultHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Fault) != 0) { FaultHeaders = (HeaderInfo[])faultHeaderList.ToArray(typeof(HeaderInfo)); XmlReflectionMember[] members = BuildHeadersReflectionMembers(FaultHeaders); if (Use == SoapBindingUse.Literal) { FaultHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false); } else { FaultHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false); } faultHeadersSerializerId = parent.RegisterSerializer(FaultHeaderMembersMapping); } SoapExtensions = SoapExtension.GetMethodExtensions(source); }