private ImportMembersMapping ( |
||
xmlReflectionMembers | ||
ns | string | |
hasWrapperElement | bool | |
rpc | bool | |
openModel | bool | |
limiter | ||
return |
public void ExportXmlSerializable_NestedClassMapping () { XmlSchemas schemas = new XmlSchemas (); XmlReflectionMember xmlReflectionMember = new XmlReflectionMember (); XmlSchemaExporter xmlSchemaExporter = new XmlSchemaExporter (schemas); XmlReflectionImporter xmlReflectionImporter = new XmlReflectionImporter (); //Export mapping for DataSet1 class. xmlReflectionMember.MemberType = typeof (DataSet1); XmlMembersMapping xmlMembersMapping = xmlReflectionImporter.ImportMembersMapping ("DataSet1Response", "ResponseNamespace", new XmlReflectionMember [] { xmlReflectionMember }, true); xmlSchemaExporter.ExportMembersMapping (xmlMembersMapping); //Export mapping for nested of DataSet1 class. xmlReflectionMember.MemberType = typeof (DataSet1.DataTable1DataTable); xmlMembersMapping = xmlReflectionImporter.ImportMembersMapping ("DataTable1DataTableResponse", "ResponseNamespace", new XmlReflectionMember [] { xmlReflectionMember }, true); xmlSchemaExporter.ExportMembersMapping (xmlMembersMapping); }
// // 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); } InputMembersMapping.SetKey(RequestName); OutputMembersMapping.SetKey(ResponseName); 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); InputHeaderMembersMapping.SetKey(RequestName + ":InHeaders"); 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); OutputHeaderMembersMapping.SetKey(ResponseName + ":OutHeaders"); 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); }
XmlSerializer GetSerializer (MessageBodyDescription desc) { if (bodySerializers.ContainsKey (desc)) return bodySerializers [desc]; int count = desc.Parts.Count + (HasReturnValue (desc) ? 1 : 0); XmlReflectionMember [] members = new XmlReflectionMember [count]; int ind = 0; if (HasReturnValue (desc)) members [ind++] = CreateReflectionMember (desc.ReturnValue, true); foreach (MessagePartDescription partDesc in desc.Parts) members [ind++] = CreateReflectionMember (partDesc, false); XmlReflectionImporter xmlImporter = new XmlReflectionImporter (); // Register known types into xmlImporter. foreach (var type in OperationKnownTypes) xmlImporter.IncludeType (type); XmlMembersMapping [] partsMapping = new XmlMembersMapping [1]; partsMapping [0] = xmlImporter.ImportMembersMapping (desc.WrapperName, desc.WrapperNamespace, members, true); bodySerializers [desc] = XmlSerializer.FromMappings (partsMapping) [0]; return bodySerializers [desc]; }
static XmlMembersMapping ImportMembersMapping(XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, bool serviceDefaultIsEncoded, bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, string elementName, string elementNamespace, bool nsIsDefault, XmlReflectionMember[] members, bool validate, bool openModel, string key, bool writeAccess) { XmlMembersMapping mapping = null; if (use == SoapBindingUse.Encoded) { string ns = (!rpc && paramStyle != SoapParameterStyle.Bare && nsIsDefault) ? GetEncodedNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace; mapping = soapImporter.ImportMembersMapping(elementName, ns, members, rpc || paramStyle != SoapParameterStyle.Bare, rpc, validate, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read); } else { string ns = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace; mapping = xmlImporter.ImportMembersMapping(elementName, ns, members, paramStyle != SoapParameterStyle.Bare, rpc, openModel, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read); } if (mapping != null) { mapping.SetKey(key); } return mapping; }
private XmlMembersMapping MembersMap(Type t, XmlAttributeOverrides overrides, XmlReflectionMember [] members, bool inContainer) { XmlReflectionImporter ri = new XmlReflectionImporter(overrides); XmlMembersMapping mm = ri.ImportMembersMapping(null, null, members, inContainer); return mm; }
[Category ("NotDotNet")] // hangs on .NET 1.1 #endif public void HandleOutAttributeParameters () { XmlReflectionMember m = new XmlReflectionMember (); m.MemberName = "hooray"; m.MemberType = typeof (string); m.XmlAttributes = new XmlAttributes (); m.XmlAttributes.XmlAttribute = new XmlAttributeAttribute (); XmlReflectionImporter imp = new XmlReflectionImporter (); XmlMembersMapping map = imp.ImportMembersMapping ( "elem", "urn:x", new XmlReflectionMember [] {m}, true); XmlSerializer ser = XmlSerializer.FromMappings ( new XmlMapping [] {map}) [0]; string xml = "<elem xmlns='urn:x' hooray='doh' />"; object [] arr = ser.Deserialize (new StringReader (xml)) as object []; Assert.IsNotNull (arr, "#1"); Assert.AreEqual (1, arr.Length, "#2"); Assert.AreEqual ("doh", arr [0], "#3"); xml = "<elem xmlns='urn:x' hooray='doh'></elem>"; arr = ser.Deserialize (new StringReader (xml)) as object []; Assert.IsNotNull (arr, "#4"); Assert.AreEqual (1, arr.Length, "#5"); Assert.AreEqual ("doh", arr [0], "#6"); }
public void InvalidNullableTypeTest () { XmlReflectionMember [] out_members = new XmlReflectionMember [1]; XmlReflectionMember m; m = new XmlReflectionMember (); m.IsReturnValue = false; m.MemberName = "HasPermissionsForUserResultSpecified"; m.MemberType = typeof (bool); m.SoapAttributes = new SoapAttributes (); m.XmlAttributes = new XmlAttributes (); m.XmlAttributes.XmlIgnore = true; m.XmlAttributes.XmlElements.Add (new XmlElementAttribute () { IsNullable = true }); out_members [0] = m; XmlReflectionImporter xmlImporter = new XmlReflectionImporter (); try { xmlImporter.ImportMembersMapping ("HasPermissionsForUserResponse", "http://tempuri.org", out_members, true); Assert.Fail ("Expected InvalidOperationException"); } catch (InvalidOperationException) { } }
[Test] // bug bxc 4367 public void SpecifiedXmlIgnoreTest () { XmlReflectionMember [] out_members = new XmlReflectionMember [2]; XmlReflectionMember m; m = new XmlReflectionMember (); m.IsReturnValue = false; m.MemberName = "HasPermissionsForUserResult"; m.MemberType = typeof (bool); m.SoapAttributes = new SoapAttributes (); m.XmlAttributes = new XmlAttributes (); out_members [0] = m; m = new XmlReflectionMember (); m.IsReturnValue = false; m.MemberName = "HasPermissionsForUserResultSpecified"; m.MemberType = typeof (bool); m.SoapAttributes = new SoapAttributes (); m.XmlAttributes = new XmlAttributes (); m.XmlAttributes.XmlIgnore = true; out_members [1] = m; XmlReflectionImporter xmlImporter = new XmlReflectionImporter (); XmlMembersMapping OutputMembersMapping = xmlImporter.ImportMembersMapping ("HasPermissionsForUserResponse", "http://tempuri.org", out_members, true); XmlSerializer xmlSerializer = XmlSerializer.FromMappings (new XmlMapping [] { OutputMembersMapping }) [0]; Assert.AreEqual (2, OutputMembersMapping.Count, "#count"); string msg = @" <HasPermissionsForUserResponse xmlns=""http://tempuri.org/""> <HasPermissionsForUserResult>true</HasPermissionsForUserResult> </HasPermissionsForUserResponse> "; object res = xmlSerializer.Deserialize (new StringReader (msg)); Assert.AreEqual (typeof (object[]), res.GetType (), "type"); Assert.AreEqual (2, ((object[]) res).Length, "length"); }