private object GenerateMembersElement(XmlMembersMapping xmlMapping) { // #10675: we should implement this method. WCF is the major customer of the method // as WCF uses XmlReflectionImporter.ImportMembersMapping and generates special // serializers for OperationContracts. throw new NotImplementedException(); }
/// <include file='doc\XmlCodeExporter.uex' path='docs/doc[@for="XmlCodeExporter.ExportMembersMapping"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { xmlMembersMapping.CheckShallow(); CheckScope(xmlMembersMapping.Scope); for (int i = 0; i < xmlMembersMapping.Count; i++) { AccessorMapping mapping = xmlMembersMapping[i].Mapping; if (mapping.Xmlns == null) { if (mapping.Attribute != null) { ExportType(mapping.Attribute.Mapping, Accessor.UnescapeName(mapping.Attribute.Name), mapping.Attribute.Namespace, null, false); } if (mapping.Elements != null) { for (int j = 0; j < mapping.Elements.Length; j++) { ElementAccessor element = mapping.Elements[j]; ExportType(element.Mapping, Accessor.UnescapeName(element.Name), element.Namespace, null, false); } } if (mapping.Text != null) { ExportType(mapping.Text.Mapping, Accessor.UnescapeName(mapping.Text.Name), mapping.Text.Namespace, null, false); } } } }
private void CreateEncodedMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped) { this.SoapExporter.ExportMembersMapping(members, wrapped); if (wrapped) { MessagePart messagePart = new MessagePart { Name = "parameters", Type = new XmlQualifiedName(members.TypeName, members.TypeNamespace) }; message.Parts.Add(messagePart); } else { for (int i = 0; i < members.Count; i++) { XmlMemberMapping mapping = members[i]; MessagePart part2 = new MessagePart { Name = mapping.XsdElementName, Type = new XmlQualifiedName(mapping.TypeName, mapping.TypeNamespace) }; message.Parts.Add(part2); } } messageBinding.Extensions.Add(this.CreateSoapBodyBinding(SoapBindingUse.Encoded, members.Namespace)); }
protected virtual void WriteMessage(XmlMembersMapping membersMap, object[] parameters) { if (membersMap.HasWrapperElement) { TopLevelElement(); WriteStartElement(membersMap.ElementName, membersMap.Namespace, (_format == SerializationFormat.Encoded)); if (Writer.LookupPrefix(XmlSchema.Namespace) == null) { WriteAttribute("xmlns", "xsd", XmlSchema.Namespace, XmlSchema.Namespace); } if (Writer.LookupPrefix(XmlSchema.InstanceNamespace) == null) { WriteAttribute("xmlns", "xsi", XmlSchema.InstanceNamespace, XmlSchema.InstanceNamespace); } } WriteMembers((ClassMap)membersMap.ObjectMap, parameters, true); if (membersMap.HasWrapperElement) { WriteEndElement(); } }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { xmlMembersMapping.CheckShallow(); base.CheckScope(xmlMembersMapping.Scope); for (int i = 0; i < xmlMembersMapping.Count; i++) { AccessorMapping mapping = xmlMembersMapping[i].Mapping; if (mapping.Xmlns == null) { if (mapping.Attribute != null) { this.ExportType(mapping.Attribute.Mapping, Accessor.UnescapeName(mapping.Attribute.Name), mapping.Attribute.Namespace, null, false); } if (mapping.Elements != null) { for (int j = 0; j < mapping.Elements.Length; j++) { ElementAccessor accessor = mapping.Elements[j]; this.ExportType(accessor.Mapping, Accessor.UnescapeName(accessor.Name), accessor.Namespace, null, false); } } if (mapping.Text != null) { this.ExportType(mapping.Text.Mapping, Accessor.UnescapeName(mapping.Text.Name), mapping.Text.Namespace, null, false); } } } }
/// <include file='doc\XmlSchemaExporter.uex' path='docs/doc[@for="XmlSchemaExporter.ExportMembersMapping1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType) { xmlMembersMapping.CheckShallow(); MembersMapping mapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping; CheckScope(xmlMembersMapping.Scope); if (mapping.HasWrapperElement && exportEnclosingType) { ExportElement(xmlMembersMapping.Accessor); } else { foreach (MemberMapping member in mapping.Members) { if (member.Attribute != null) throw new InvalidOperationException(Res.GetString(Res.XmlBareAttributeMember, member.Attribute.Name)); else if (member.Text != null) throw new InvalidOperationException(Res.GetString(Res.XmlBareTextMember, member.Text.Name)); else if (member.Elements == null || member.Elements.Length == 0) continue; if (member.TypeDesc.IsArrayLike && !(member.Elements[0].Mapping is ArrayMapping)) throw new InvalidOperationException(Res.GetString(Res.XmlIllegalArrayElement, member.Elements[0].Name)); if (exportEnclosingType) { ExportElement(member.Elements[0]); } else { ExportMapping(member.Elements[0].Mapping, member.Elements[0].Namespace, member.Elements[0].Any); } } } ExportRootIfNecessary(xmlMembersMapping.Scope); }
/// <include file='doc\SoapCodeExporter.uex' path='docs/doc[@for="SoapCodeExporter.ExportMembersMapping"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { CheckScope(xmlMembersMapping.Scope); CheckNamespace(); for (int i = 0; i < xmlMembersMapping.Count; i++) { ExportElement((ElementAccessor)xmlMembersMapping[i].Accessor); } }
protected virtual object ReadMessage(XmlMembersMapping typeMap) { object[] array = new object[typeMap.Count]; if (typeMap.HasWrapperElement) { ArrayList allMembers = ((ClassMap)typeMap.ObjectMap).AllMembers; for (int i = 0; i < allMembers.Count; i++) { XmlTypeMapMember xmlTypeMapMember = (XmlTypeMapMember)allMembers[i]; if (!xmlTypeMapMember.IsReturnValue && xmlTypeMapMember.TypeData.IsValueType) { this.SetMemberValueFromAttr(xmlTypeMapMember, array, this.CreateInstance(xmlTypeMapMember.TypeData.Type), true); } } if (this._format == SerializationFormat.Encoded) { while (base.Reader.NodeType == XmlNodeType.Element) { string attribute = base.Reader.GetAttribute("root", "http://schemas.xmlsoap.org/soap/encoding/"); if (attribute == null || XmlConvert.ToBoolean(attribute)) { break; } base.ReadReferencedElement(); base.Reader.MoveToContent(); } } while (base.Reader.NodeType != XmlNodeType.EndElement && base.Reader.ReadState == ReadState.Interactive) { if (base.Reader.IsStartElement(typeMap.ElementName, typeMap.Namespace) || this._format == SerializationFormat.Encoded) { this.ReadAttributeMembers((ClassMap)typeMap.ObjectMap, array, true); if (!base.Reader.IsEmptyElement) { base.Reader.ReadStartElement(); this.ReadMembers((ClassMap)typeMap.ObjectMap, array, true, false); base.ReadEndElement(); break; } base.Reader.Skip(); base.Reader.MoveToContent(); } else { base.UnknownNode(null); base.Reader.MoveToContent(); } } } else { this.ReadMembers((ClassMap)typeMap.ObjectMap, array, true, this._format == SerializationFormat.Encoded); } if (this._format == SerializationFormat.Encoded) { base.ReadReferencedElements(); } return(array); }
internal void Add(MessagePartDescription part, XmlMemberMapping memberMapping, XmlMembersMapping membersMapping, bool isEncoded) { PartInfo partInfo = new PartInfo(); partInfo.MemberMapping = memberMapping; partInfo.MembersMapping = membersMapping; partInfo.IsEncoded = isEncoded; partInfoTable[part] = partInfo; }
/// <include file='doc\SoapCodeExporter.uex' path='docs/doc[@for="SoapCodeExporter.ExportMembersMapping"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { xmlMembersMapping.CheckShallow(); CheckScope(xmlMembersMapping.Scope); for (int i = 0; i < xmlMembersMapping.Count; i++) { ExportElement((ElementAccessor)xmlMembersMapping[i].Accessor); } }
internal SoapParameters(XmlMembersMapping request, XmlMembersMapping response, string[] parameterOrder, CodeIdentifiers identifiers) { ArrayList requestList = new ArrayList(); ArrayList responseList = new ArrayList(); AddMappings(requestList, request); if (response != null) AddMappings(responseList, response); if (parameterOrder != null) { for (int i = 0; i < parameterOrder.Length; i++) { string elementName = parameterOrder[i]; XmlMemberMapping requestMapping = FindMapping(requestList, elementName); SoapParameter parameter = new SoapParameter(); if (requestMapping != null) { if (RemoveByRefMapping(responseList, requestMapping)) parameter.codeFlags = CodeFlags.IsByRef; parameter.mapping = requestMapping; requestList.Remove(requestMapping); AddParameter(parameter); } else { XmlMemberMapping responseMapping = FindMapping(responseList, elementName); if (responseMapping != null) { parameter.codeFlags = CodeFlags.IsOut; parameter.mapping = responseMapping; responseList.Remove(responseMapping); AddParameter(parameter); } } } } foreach (XmlMemberMapping requestMapping in requestList) { SoapParameter parameter = new SoapParameter(); if (RemoveByRefMapping(responseList, requestMapping)) parameter.codeFlags = CodeFlags.IsByRef; parameter.mapping = requestMapping; AddParameter(parameter); } if (responseList.Count > 0) { if (!((XmlMemberMapping) responseList[0]).CheckSpecified) { ret = (XmlMemberMapping)responseList[0]; responseList.RemoveAt(0); } foreach (XmlMemberMapping responseMapping in responseList) { SoapParameter parameter = new SoapParameter(); parameter.mapping = responseMapping; parameter.codeFlags = CodeFlags.IsOut; AddParameter(parameter); } } foreach (SoapParameter parameter in parameters) { parameter.name = identifiers.MakeUnique(CodeIdentifier.MakeValid(parameter.mapping.MemberName)); } }
/// <include file='doc\XmlCodeExporter.uex' path='docs/doc[@for="XmlCodeExporter.ExportMembersMapping"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { CheckScope(xmlMembersMapping.Scope); CheckNamespace(); for (int i = 0; i < xmlMembersMapping.Count; i++) { Accessor accessor = xmlMembersMapping[i].Accessor; if (!(accessor is XmlnsAccessor)) { ExportType(accessor.Mapping, Accessor.UnescapeName(accessor.Name), accessor.Namespace, null); } } }
protected virtual object ReadMessage(XmlMembersMapping typeMap) { object[] parameters = new object[typeMap.Count]; if (typeMap.HasWrapperElement) { if (_format == SerializationFormat.Encoded) { while (Reader.NodeType == System.Xml.XmlNodeType.Element) { string root = Reader.GetAttribute("root", XmlSerializer.EncodingNamespace); if (root == null || System.Xml.XmlConvert.ToBoolean(root)) { break; } ReadReferencedElement(); Reader.MoveToContent(); } } while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) { if (Reader.IsStartElement(typeMap.ElementName, typeMap.Namespace) || _format == SerializationFormat.Encoded) { if (Reader.IsEmptyElement) { Reader.Skip(); Reader.MoveToContent(); continue; } Reader.ReadStartElement(); ReadMembers((ClassMap)typeMap.ObjectMap, parameters, true, false); ReadEndElement(); break; } else { UnknownNode(null); } Reader.MoveToContent(); } } else { ReadMembers((ClassMap)typeMap.ObjectMap, parameters, true, _format == SerializationFormat.Encoded); } if (_format == SerializationFormat.Encoded) { ReadReferencedElements(); } return(parameters); }
/// <include file='doc\SoapSchemaExporter.uex' path='docs/doc[@for="SoapSchemaExporter.ExportMembersMapping1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType) { CheckScope(xmlMembersMapping.Scope); MembersMapping membersMapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping; if (exportEnclosingType) { ExportTypeMapping(membersMapping, null); } else { foreach (MemberMapping memberMapping in membersMapping.Members) { if (memberMapping.Elements.Length > 0) ExportTypeMapping(memberMapping.Elements[0].Mapping, null); } } }
public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate) { XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length]; for (int n = 0; n < members.Length; n++) { XmlTypeMapMember mapMem = CreateMapMember(members[n], ns); mapping[n] = new XmlMemberMapping(members[n].MemberName, ns, mapMem, true); } XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, mapping); mps.RelatedMaps = relatedMaps; mps.Format = SerializationFormat.Encoded; mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, includedTypes); return(mps); }
/// <include file='doc\XmlSchemaExporter.uex' path='docs/doc[@for="XmlSchemaExporter.ExportTypeMapping1"]/*' /> public XmlQualifiedName ExportTypeMapping(XmlMembersMapping xmlMembersMapping) { CheckScope(xmlMembersMapping.Scope); MembersMapping mapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping; if (mapping.Members.Length == 1 && mapping.Members[0].Elements[0].Mapping is SpecialMapping) { SpecialMapping special = (SpecialMapping)mapping.Members[0].Elements[0].Mapping; XmlSchemaType type = ExportSpecialMapping(special, xmlMembersMapping.Accessor.Namespace, false); type.Name = xmlMembersMapping.Accessor.Name; AddSchemaItem(type, xmlMembersMapping.Accessor.Namespace, null); ExportRootIfNecessary(xmlMembersMapping.Scope); return(new XmlQualifiedName(xmlMembersMapping.Accessor.Name, xmlMembersMapping.Accessor.Namespace)); } return(null); }
/// <include file='doc\SoapReflectionImporter.uex' path='docs/doc[@for="SoapReflectionImporter.ImportMembersMapping2"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate) { ElementAccessor element = new ElementAccessor(); element.IsSoap = true; element.Name = Accessor.EscapeName(elementName, false); element.Mapping = ImportMembersMapping(members, ns, hasWrapperElement, writeAccessors, validate); element.Mapping.TypeName = elementName; element.Namespace = element.Mapping.Namespace == null ? ns : element.Mapping.Namespace; element.Form = XmlSchemaForm.Qualified; XmlMembersMapping xmlMapping = new XmlMembersMapping(typeScope, element); xmlMapping.GenerateSerializer = true; return(xmlMapping); }
/// <include file='doc\XmlSchemaExporter.uex' path='docs/doc[@for="XmlSchemaExporter.ExportTypeMapping1"]/*' /> public XmlQualifiedName ExportTypeMapping(XmlMembersMapping xmlMembersMapping) { xmlMembersMapping.CheckShallow(); CheckScope(xmlMembersMapping.Scope); MembersMapping mapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping; if (mapping.Members.Length == 1 && mapping.Members[0].Elements[0].Mapping is SpecialMapping) { SpecialMapping special = (SpecialMapping)mapping.Members[0].Elements[0].Mapping; XmlSchemaType type = ExportSpecialMapping(special, xmlMembersMapping.Accessor.Namespace, false, null); if (type != null && type.Name != null && type.Name.Length > 0) { type.Name = xmlMembersMapping.Accessor.Name; AddSchemaItem(type, xmlMembersMapping.Accessor.Namespace, null); } ExportRootIfNecessary(xmlMembersMapping.Scope); return (new XmlQualifiedName(xmlMembersMapping.Accessor.Name, xmlMembersMapping.Accessor.Namespace)); } return null; }
XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access) { elementName = XmlConvert.EncodeLocalName(elementName); XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length]; for (int n = 0; n < members.Length; n++) { XmlTypeMapMember mapMem = CreateMapMember(members[n], ns); mapping[n] = new XmlMemberMapping(XmlConvert.EncodeLocalName(members[n].MemberName), ns, mapMem, true); } XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, mapping); mps.RelatedMaps = relatedMaps; mps.Format = SerializationFormat.Encoded; Type[] extraTypes = includedTypes != null ? (Type[])includedTypes.ToArray(typeof(Type)) : null; mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, extraTypes); return(mps); }
public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access) { elementName = XmlConvert.EncodeLocalName(elementName); XmlMemberMapping[] array = new XmlMemberMapping[members.Length]; for (int i = 0; i < members.Length; i++) { XmlTypeMapMember mapMem = this.CreateMapMember(members[i], ns); array[i] = new XmlMemberMapping(XmlConvert.EncodeLocalName(members[i].MemberName), ns, mapMem, true); } XmlMembersMapping xmlMembersMapping = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, array); xmlMembersMapping.RelatedMaps = this.relatedMaps; xmlMembersMapping.Format = SerializationFormat.Encoded; Type[] array2 = (this.includedTypes == null) ? null : ((Type[])this.includedTypes.ToArray(typeof(Type))); xmlMembersMapping.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, array2); return(xmlMembersMapping); }
/// <include file='doc\SoapReflectionImporter.uex' path='docs/doc[@for="SoapReflectionImporter.ImportMembersMapping3"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access) { ElementAccessor element = new ElementAccessor(); element.IsSoap = true; element.Name = elementName == null || elementName.Length == 0 ? elementName : XmlConvert.EncodeLocalName(elementName); element.Mapping = ImportMembersMapping(members, ns, hasWrapperElement, writeAccessors, validate, new RecursionLimiter()); element.Mapping.TypeName = elementName; element.Namespace = element.Mapping.Namespace == null ? ns : element.Mapping.Namespace; element.Form = XmlSchemaForm.Qualified; XmlMembersMapping xmlMapping = new XmlMembersMapping(_typeScope, element, access); xmlMapping.IsSoap = true; xmlMapping.GenerateSerializer = true; return(xmlMapping); }
/// <include file='doc\SoapSchemaExporter.uex' path='docs/doc[@for="SoapSchemaExporter.ExportMembersMapping1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType) { CheckScope(xmlMembersMapping.Scope); MembersMapping membersMapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping; if (exportEnclosingType) { ExportTypeMapping(membersMapping, null); } else { foreach (MemberMapping memberMapping in membersMapping.Members) { if (memberMapping.Elements.Length > 0) { ExportTypeMapping(memberMapping.Elements[0].Mapping, null); } } } }
protected virtual void WriteMessage(XmlMembersMapping membersMap, object[] parameters) { if (membersMap.HasWrapperElement) { base.TopLevelElement(); base.WriteStartElement(membersMap.ElementName, membersMap.Namespace, this._format == SerializationFormat.Encoded); if (base.Writer.LookupPrefix("http://www.w3.org/2001/XMLSchema") == null) { base.WriteAttribute("xmlns", "xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema"); } if (base.Writer.LookupPrefix("http://www.w3.org/2001/XMLSchema-instance") == null) { base.WriteAttribute("xmlns", "xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/2001/XMLSchema-instance"); } } this.WriteMembers((ClassMap)membersMap.ObjectMap, parameters, true); if (membersMap.HasWrapperElement) { base.WriteEndElement(); } }
public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember [] members, bool hasWrapperElement) { // Reset (); Disabled. See ChangeLog XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length]; for (int n = 0; n < members.Length; n++) { XmlTypeMapMember mapMem = CreateMapMember(members[n], ns); mapping[n] = new XmlMemberMapping(members[n].MemberName, ns, mapMem, false); } XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, false, mapping); mps.RelatedMaps = relatedMaps; mps.Format = SerializationFormat.Literal; mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, false, true, ns, includedTypes); if (allowPrivateTypes) { mps.Source.CanBeGenerated = false; } return(mps); }
/// <include file='doc\XmlSchemaExporter.uex' path='docs/doc[@for="XmlSchemaExporter.ExportMembersMapping"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { MembersMapping mapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping; CheckScope(xmlMembersMapping.Scope); if (mapping.HasWrapperElement) { ExportElement(xmlMembersMapping.Accessor); } else { foreach (MemberMapping member in mapping.Members) { if (member.Attribute != null) { throw new InvalidOperationException(Res.GetString(Res.XmlBareAttributeMember, member.Attribute.Name)); } else if (member.Text != null) { throw new InvalidOperationException(Res.GetString(Res.XmlBareTextMember, member.Text.Name)); } else if (member.Elements == null || member.Elements.Length == 0) { continue; } if (member.TypeDesc.IsArray && !(member.Elements[0].Mapping is ArrayMapping)) { throw new InvalidOperationException(Res.GetString(Res.XmlIllegalArrayElement, member.Elements[0].Name)); } ExportElement(member.Elements[0]); } } ExportRootIfNecessary(xmlMembersMapping.Scope); }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { ExportMembersMapping(xmlMembersMapping, true); }
protected virtual object ReadMessage(XmlMembersMapping typeMap) { object[] parameters = new object[typeMap.Count]; if (typeMap.HasWrapperElement) { // bug #79988: out parameters need to be initialized if they // are value types ArrayList members = ((ClassMap)typeMap.ObjectMap).AllMembers; for (int n = 0; n < members.Count; n++) { XmlTypeMapMember mem = (XmlTypeMapMember)members [n]; if (!mem.IsReturnValue && mem.TypeData.IsValueType) { SetMemberValueFromAttr(mem, parameters, CreateInstance( mem.TypeData.Type), true); } } if (_format == SerializationFormat.Encoded) { while (Reader.NodeType == System.Xml.XmlNodeType.Element) { string root = Reader.GetAttribute("root", XmlSerializer.EncodingNamespace); if (root == null || System.Xml.XmlConvert.ToBoolean(root)) { break; } ReadReferencedElement(); Reader.MoveToContent(); } } while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && // it could be an empty root element Reader.ReadState == ReadState.Interactive) { if (Reader.IsStartElement(typeMap.ElementName, typeMap.Namespace) || _format == SerializationFormat.Encoded) { ReadAttributeMembers((ClassMap)typeMap.ObjectMap, parameters, true); if (Reader.IsEmptyElement) { Reader.Skip(); Reader.MoveToContent(); continue; } Reader.ReadStartElement(); ReadMembers((ClassMap)typeMap.ObjectMap, parameters, true, false); ReadEndElement(); break; } else { UnknownNode(null); } Reader.MoveToContent(); } } else { ReadMembers((ClassMap)typeMap.ObjectMap, parameters, true, _format == SerializationFormat.Encoded); } if (_format == SerializationFormat.Encoded) { ReadReferencedElements(); } return(parameters); }
string GenerateLiteralMembersElement(XmlMembersMapping xmlMembersMapping) { ElementAccessor element = xmlMembersMapping.Accessor; MemberMapping[] mappings = ((MembersMapping)element.Mapping).Members; bool hasWrapperElement = ((MembersMapping)element.Mapping).HasWrapperElement; string methodName = NextMethodName(element.Name); Writer.WriteLine(); Writer.Write("public object[] "); Writer.Write(methodName); Writer.WriteLine("() {"); Writer.Indent++; Writer.WriteLine("Reader.MoveToContent();"); Writer.Write("object[] p = new object["); Writer.Write(mappings.Length.ToString(CultureInfo.InvariantCulture)); Writer.WriteLine("];"); InitializeValueTypes("p", mappings); int wrapperLoopIndex = 0; if (hasWrapperElement) { wrapperLoopIndex = WriteWhileNotLoopStart(); Writer.Indent++; WriteIsStartTag(element.Name, element.Form == XmlSchemaForm.Qualified ? element.Namespace : ""); } Member anyText = null; Member anyElement = null; Member anyAttribute = null; ArrayList membersList = new ArrayList(); ArrayList textOrArrayMembersList = new ArrayList(); ArrayList attributeMembersList = new ArrayList(); for (int i = 0; i < mappings.Length; i++) { MemberMapping mapping = mappings[i]; string source = "p[" + i.ToString(CultureInfo.InvariantCulture) + "]"; string arraySource = source; if (mapping.Xmlns != null) { arraySource = "((" + mapping.TypeDesc.CSharpName + ")" + source + ")"; } string choiceSource = GetChoiceIdentifierSource(mappings, mapping); Member member = new Member(this, source, arraySource, "a", i, mapping, choiceSource); Member anyMember = new Member(this, source, null, "a", i, mapping, choiceSource); if (!mapping.IsSequence) member.ParamsReadSource = "paramsRead[" + i.ToString(CultureInfo.InvariantCulture) + "]"; if (mapping.CheckSpecified == SpecifiedAccessor.ReadWrite) { string nameSpecified = mapping.Name + "Specified"; for (int j = 0; j < mappings.Length; j++) { if (mappings[j].Name == nameSpecified) { member.CheckSpecifiedSource = "p[" + j.ToString(CultureInfo.InvariantCulture) + "]"; break; } } } bool foundAnyElement = false; if (mapping.Text != null) anyText = anyMember; if (mapping.Attribute != null && mapping.Attribute.Any) anyAttribute = anyMember; if (mapping.Attribute != null || mapping.Xmlns != null) attributeMembersList.Add(member); else if (mapping.Text != null) textOrArrayMembersList.Add(member); if (!mapping.IsSequence) { for (int j = 0; j < mapping.Elements.Length; j++) { if (mapping.Elements[j].Any && mapping.Elements[j].Name.Length == 0) { anyElement = anyMember; if (mapping.Attribute == null && mapping.Text == null) textOrArrayMembersList.Add(anyMember); foundAnyElement = true; break; } } } if (mapping.Attribute != null || mapping.Text != null || foundAnyElement) membersList.Add(anyMember); else if (mapping.TypeDesc.IsArrayLike && !(mapping.Elements.Length == 1 && mapping.Elements[0].Mapping is ArrayMapping)) { membersList.Add(anyMember); textOrArrayMembersList.Add(anyMember); } else { if (mapping.TypeDesc.IsArrayLike && !mapping.TypeDesc.IsArray) member.ParamsReadSource = null; // collection membersList.Add(member); } } Member[] members = (Member[]) membersList.ToArray(typeof(Member)); Member[] textOrArrayMembers = (Member[]) textOrArrayMembersList.ToArray(typeof(Member)); if (members.Length > 0 && members[0].Mapping.IsReturnValue) Writer.WriteLine("IsReturnValue = true;"); WriteParamsRead(mappings.Length); if (attributeMembersList.Count > 0) { Member[] attributeMembers = (Member[]) attributeMembersList.ToArray(typeof(Member)); WriteMemberBegin(attributeMembers); WriteAttributes(attributeMembers, anyAttribute, "UnknownNode", "(object)p"); WriteMemberEnd(attributeMembers); Writer.WriteLine("Reader.MoveToElement();"); } WriteMemberBegin(textOrArrayMembers); if (hasWrapperElement) { Writer.WriteLine("if (Reader.IsEmptyElement) { Reader.Skip(); Reader.MoveToContent(); continue; }"); Writer.WriteLine("Reader.ReadStartElement();"); } if (IsSequence(members)) { Writer.WriteLine("int state = 0;"); } int loopIndex = WriteWhileNotLoopStart(); Writer.Indent++; string unknownNode = "UnknownNode((object)p, " + ExpectedElements(members) + ");"; WriteMemberElements(members, unknownNode, unknownNode, anyElement, anyText, null); Writer.WriteLine("Reader.MoveToContent();"); WriteWhileLoopEnd(loopIndex); WriteMemberEnd(textOrArrayMembers); if (hasWrapperElement) { Writer.WriteLine("ReadEndElement();"); Writer.Indent--; Writer.WriteLine("}"); WriteUnknownNode("UnknownNode", "null", element, true); Writer.WriteLine("Reader.MoveToContent();"); WriteWhileLoopEnd(wrapperLoopIndex); } Writer.WriteLine("return p;"); Writer.Indent--; Writer.WriteLine("}"); return methodName; }
void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers, bool rpc) { // if (use == SoapBindingUse.Encoded) { SoapExporter.ExportMembersMapping(inHeaderMappings, false); if (outHeaderMappings != null) SoapExporter.ExportMembersMapping(outHeaderMappings, false); } else { SchemaExporter.ExportMembersMapping(inHeaderMappings); if (outHeaderMappings != null) SchemaExporter.ExportMembersMapping(outHeaderMappings); } CodeIdentifiers identifiers = new CodeIdentifiers(); int inCount = 0, outCount = 0; for (int i = 0; i < headers.Length; i++) { SoapReflectedHeader soapHeader = headers[i]; if (!soapHeader.custom) continue; XmlMemberMapping member; if ((soapHeader.direction & SoapHeaderDirection.In) != 0) { member = inHeaderMappings[inCount++]; if (soapHeader.direction != SoapHeaderDirection.In) outCount++; } else { member = outHeaderMappings[outCount++]; } MessagePart part = new MessagePart(); part.Name = member.XsdElementName; if (use == SoapBindingUse.Encoded) part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace); else part.Element = new XmlQualifiedName(member.XsdElementName, member.Namespace); Message message = new Message(); message.Name = identifiers.AddUnique(methodName + part.Name, message); message.Parts.Add(part); HeaderMessages.Add(message); ServiceDescriptionFormatExtension soapHeaderBinding = CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, Binding.ServiceDescription.TargetNamespace), part.Name, rpc ? member.Namespace : null, use); if ((soapHeader.direction & SoapHeaderDirection.In) != 0) OperationBinding.Input.Extensions.Add(soapHeaderBinding); if ((soapHeader.direction & SoapHeaderDirection.Out) != 0) OperationBinding.Output.Extensions.Add(soapHeaderBinding); if ((soapHeader.direction & SoapHeaderDirection.Fault) != 0) { if (soapMethod.IsClaimsConformance) { throw new InvalidOperationException(Res.GetString(Res.BPConformanceHeaderFault, soapMethod.methodInfo.ToString(), soapMethod.methodInfo.DeclaringType.FullName, "Direction", typeof(SoapHeaderDirection).Name, SoapHeaderDirection.Fault.ToString())); } OperationBinding.Output.Extensions.Add(soapHeaderBinding); } } }
void CreateMessage(bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, Message message, MessageBinding messageBinding, XmlMembersMapping members) { bool wrapped = paramStyle != SoapParameterStyle.Bare; if (use == SoapBindingUse.Encoded) CreateEncodedMessage(message, messageBinding, members, wrapped && !rpc); else CreateLiteralMessage(message, messageBinding, members, wrapped && !rpc, rpc); }
CodeMemberMethod GenerateMethod (CodeIdentifiers memberIds, HttpOperationBinding httpOper, XmlMembersMapping inputMembers, XmlTypeMapping outputMember) { CodeIdentifiers pids = new CodeIdentifiers (); CodeMemberMethod method = new CodeMemberMethod (); CodeMemberMethod methodBegin = new CodeMemberMethod (); CodeMemberMethod methodEnd = new CodeMemberMethod (); method.Attributes = MemberAttributes.Public; methodBegin.Attributes = MemberAttributes.Public; methodEnd.Attributes = MemberAttributes.Public; // Find unique names for temporary variables for (int n=0; n<inputMembers.Count; n++) pids.AddUnique (inputMembers[n].MemberName, inputMembers[n]); string varAsyncResult = pids.AddUnique ("asyncResult","asyncResult"); string varCallback = pids.AddUnique ("callback","callback"); string varAsyncState = pids.AddUnique ("asyncState","asyncState"); string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name),method); method.Name = Operation.Name; methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + Operation.Name),method); methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + Operation.Name),method); method.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.Parameters.Add (new CodeParameterDeclarationExpression (typeof (IAsyncResult),varAsyncResult)); CodeExpression[] paramArray = new CodeExpression [inputMembers.Count]; for (int n=0; n<inputMembers.Count; n++) { string ptype = GetSimpleType (inputMembers[n]); CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (ptype, inputMembers[n].MemberName); param.Direction = FieldDirection.In; method.Parameters.Add (param); methodBegin.Parameters.Add (param); paramArray [n] = new CodeVariableReferenceExpression (param.Name); } bool isVoid = true; if (outputMember != null) { method.ReturnType = new CodeTypeReference (outputMember.TypeFullName); methodEnd.ReturnType = new CodeTypeReference (outputMember.TypeFullName); xmlExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, outputMember, ""); isVoid = false; } methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (AsyncCallback),varCallback)); methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object),varAsyncState)); methodBegin.ReturnType = new CodeTypeReference (typeof(IAsyncResult)); // Array of input parameters CodeArrayCreateExpression methodParams; if (paramArray.Length > 0) methodParams = new CodeArrayCreateExpression (typeof(object), paramArray); else methodParams = new CodeArrayCreateExpression (typeof(object), 0); // Generate method url CodeThisReferenceExpression ethis = new CodeThisReferenceExpression(); CodeExpression thisURlExp = new CodeFieldReferenceExpression (ethis, "Url"); CodePrimitiveExpression metUrl = new CodePrimitiveExpression (httpOper.Location); CodeBinaryOperatorExpression expMethodLocation = new CodeBinaryOperatorExpression (thisURlExp, CodeBinaryOperatorType.Add, metUrl); // Invoke call CodePrimitiveExpression varMsgName = new CodePrimitiveExpression (messageName); CodeMethodInvokeExpression inv; inv = new CodeMethodInvokeExpression (ethis, "Invoke", varMsgName, expMethodLocation, methodParams); if (!isVoid) method.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (method.ReturnType, inv))); else method.Statements.Add (inv); // Begin Invoke Call CodeExpression expCallb = new CodeVariableReferenceExpression (varCallback); CodeExpression expAsyncs = new CodeVariableReferenceExpression (varAsyncState); inv = new CodeMethodInvokeExpression (ethis, "BeginInvoke", varMsgName, expMethodLocation, methodParams, expCallb, expAsyncs); methodBegin.Statements.Add (new CodeMethodReturnStatement (inv)); // End Invoke call CodeExpression varAsyncr = new CodeVariableReferenceExpression (varAsyncResult); inv = new CodeMethodInvokeExpression (ethis, "EndInvoke", varAsyncr); if (!isVoid) methodEnd.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (methodEnd.ReturnType, inv))); else methodEnd.Statements.Add (inv); // Attributes CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.HttpMethodAttribute"); att.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(GetOutMimeFormatter ()))); att.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(GetInMimeFormatter ()))); AddCustomAttribute (method, att, true); CodeTypeDeclaration.Members.Add (method); CodeTypeDeclaration.Members.Add (methodBegin); CodeTypeDeclaration.Members.Add (methodEnd); return method; }
void GenerateReturnAttributes (XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeMemberMethod method) { if (use == SoapBindingUse.Literal) xmlExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, member, members.Namespace, (member.ElementName != method.Name + "Result")); else soapExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, member, (member.ElementName != method.Name + "Result")); }
CodeMemberMethod GenerateMethod (CodeIdentifiers memberIds, SoapOperationBinding soapOper, SoapBodyBinding bodyBinding, XmlMembersMapping inputMembers, XmlMembersMapping outputMembers) { CodeIdentifiers pids = new CodeIdentifiers (); CodeMemberMethod method = new CodeMemberMethod (); CodeMemberMethod methodBegin = new CodeMemberMethod (); CodeMemberMethod methodEnd = new CodeMemberMethod (); method.Attributes = MemberAttributes.Public | MemberAttributes.Final; methodBegin.Attributes = MemberAttributes.Public | MemberAttributes.Final; methodEnd.Attributes = MemberAttributes.Public | MemberAttributes.Final; SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style; // Find unique names for temporary variables for (int n=0; n<inputMembers.Count; n++) pids.AddUnique (inputMembers[n].MemberName, inputMembers[n]); if (outputMembers != null) for (int n=0; n<outputMembers.Count; n++) pids.AddUnique (outputMembers[n].MemberName, outputMembers[n]); string varAsyncResult = pids.AddUnique ("asyncResult","asyncResult"); string varResults = pids.AddUnique ("results","results"); string varCallback = pids.AddUnique ("callback","callback"); string varAsyncState = pids.AddUnique ("asyncState","asyncState"); string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name),method); method.Name = CodeIdentifier.MakeValid(Operation.Name); if (method.Name == ClassName) method.Name += "1"; methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + method.Name),method); methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + method.Name),method); method.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.Parameters.Add (new CodeParameterDeclarationExpression (typeof (IAsyncResult),varAsyncResult)); CodeExpression[] paramArray = new CodeExpression [inputMembers.Count]; CodeParameterDeclarationExpression[] outParams = new CodeParameterDeclarationExpression [outputMembers != null ? outputMembers.Count : 0]; for (int n=0; n<inputMembers.Count; n++) { CodeParameterDeclarationExpression param = GenerateParameter (inputMembers[n], FieldDirection.In); method.Parameters.Add (param); GenerateMemberAttributes (inputMembers, inputMembers[n], bodyBinding.Use, param); methodBegin.Parameters.Add (GenerateParameter (inputMembers[n], FieldDirection.In)); paramArray [n] = new CodeVariableReferenceExpression (param.Name); } if (outputMembers != null) { bool hasReturn = false; for (int n=0; n<outputMembers.Count; n++) { CodeParameterDeclarationExpression cpd = GenerateParameter (outputMembers[n], FieldDirection.Out); outParams [n] = cpd; bool found = false; foreach (CodeParameterDeclarationExpression ip in method.Parameters) { if (ip.Name == cpd.Name && ip.Type.BaseType == cpd.Type.BaseType) { ip.Direction = FieldDirection.Ref; methodEnd.Parameters.Add (GenerateParameter (outputMembers[n], FieldDirection.Out)); found = true; break; } } if (found) continue; if (!hasReturn) { hasReturn = true; method.ReturnType = cpd.Type; methodEnd.ReturnType = cpd.Type; GenerateReturnAttributes (outputMembers, outputMembers[n], bodyBinding.Use, method); outParams [n] = null; continue; } method.Parameters.Add (cpd); GenerateMemberAttributes (outputMembers, outputMembers[n], bodyBinding.Use, cpd); methodEnd.Parameters.Add (GenerateParameter (outputMembers[n], FieldDirection.Out)); } } methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (AsyncCallback),varCallback)); methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object),varAsyncState)); methodBegin.ReturnType = new CodeTypeReference (typeof(IAsyncResult)); // Array of input parameters CodeArrayCreateExpression methodParams; if (paramArray.Length > 0) methodParams = new CodeArrayCreateExpression (typeof(object), paramArray); else methodParams = new CodeArrayCreateExpression (typeof(object), 0); // Assignment of output parameters CodeStatementCollection outAssign = new CodeStatementCollection (); CodeVariableReferenceExpression arrVar = new CodeVariableReferenceExpression (varResults); for (int n=0; n<outParams.Length; n++) { CodeExpression index = new CodePrimitiveExpression (n); if (outParams[n] == null) { CodeExpression res = new CodeCastExpression (method.ReturnType, new CodeArrayIndexerExpression (arrVar, index)); outAssign.Add (new CodeMethodReturnStatement (res)); } else { CodeExpression res = new CodeCastExpression (outParams[n].Type, new CodeArrayIndexerExpression (arrVar, index)); CodeExpression var = new CodeVariableReferenceExpression (outParams[n].Name); outAssign.Insert (0, new CodeAssignStatement (var, res)); } } if (Style == ServiceDescriptionImportStyle.Client) { // Invoke call CodeThisReferenceExpression ethis = new CodeThisReferenceExpression(); CodePrimitiveExpression varMsgName = new CodePrimitiveExpression (messageName); CodeMethodInvokeExpression inv; CodeVariableDeclarationStatement dec; inv = new CodeMethodInvokeExpression (ethis, "Invoke", varMsgName, methodParams); if (outputMembers != null && outputMembers.Count > 0) { dec = new CodeVariableDeclarationStatement (typeof(object[]), varResults, inv); method.Statements.Add (dec); method.Statements.AddRange (outAssign); } else method.Statements.Add (inv); // Begin Invoke Call CodeExpression expCallb = new CodeVariableReferenceExpression (varCallback); CodeExpression expAsyncs = new CodeVariableReferenceExpression (varAsyncState); inv = new CodeMethodInvokeExpression (ethis, "BeginInvoke", varMsgName, methodParams, expCallb, expAsyncs); methodBegin.Statements.Add (new CodeMethodReturnStatement (inv)); // End Invoke call CodeExpression varAsyncr = new CodeVariableReferenceExpression (varAsyncResult); inv = new CodeMethodInvokeExpression (ethis, "EndInvoke", varAsyncr); if (outputMembers != null && outputMembers.Count > 0) { dec = new CodeVariableDeclarationStatement (typeof(object[]), varResults, inv); methodEnd.Statements.Add (dec); methodEnd.Statements.AddRange (outAssign); } else methodEnd.Statements.Add (inv); } else { method.Attributes = MemberAttributes.Public | MemberAttributes.Abstract; } // Attributes ImportHeaders (method); CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Web.Services.WebMethodAttribute"); if (messageName != method.Name) att.Arguments.Add (GetArg ("MessageName",messageName)); AddCustomAttribute (method, att, (Style == ServiceDescriptionImportStyle.Server)); if (style == SoapBindingStyle.Rpc) { att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.SoapRpcMethodAttribute"); att.Arguments.Add (GetArg (soapOper.SoapAction)); if (inputMembers.ElementName != method.Name) att.Arguments.Add (GetArg ("RequestElementName", inputMembers.ElementName)); if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response")) att.Arguments.Add (GetArg ("ResponseElementName", outputMembers.ElementName)); att.Arguments.Add (GetArg ("RequestNamespace", inputMembers.Namespace)); if (outputMembers != null) att.Arguments.Add (GetArg ("ResponseNamespace", outputMembers.Namespace)); if (outputMembers == null) att.Arguments.Add (GetArg ("OneWay", true)); } else { if (outputMembers != null && (inputMembers.ElementName == "" && outputMembers.ElementName != "" || inputMembers.ElementName != "" && outputMembers.ElementName == "")) throw new InvalidOperationException ("Parameter style is not the same for the input message and output message"); att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.SoapDocumentMethodAttribute"); att.Arguments.Add (GetArg (soapOper.SoapAction)); if (inputMembers.ElementName != "") { if (inputMembers.ElementName != method.Name) att.Arguments.Add (GetArg ("RequestElementName", inputMembers.ElementName)); if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response")) att.Arguments.Add (GetArg ("ResponseElementName", outputMembers.ElementName)); att.Arguments.Add (GetArg ("RequestNamespace", inputMembers.Namespace)); if (outputMembers != null) att.Arguments.Add (GetArg ("ResponseNamespace", outputMembers.Namespace)); att.Arguments.Add (GetEnumArg ("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Wrapped")); } else att.Arguments.Add (GetEnumArg ("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Bare")); if (outputMembers == null) att.Arguments.Add (GetArg ("OneWay", true)); att.Arguments.Add (GetEnumArg ("Use", "System.Web.Services.Description.SoapBindingUse", bodyBinding.Use.ToString())); } AddCustomAttribute (method, att, true); CodeTypeDeclaration.Members.Add (method); if (Style == ServiceDescriptionImportStyle.Client) { CodeTypeDeclaration.Members.Add (methodBegin); CodeTypeDeclaration.Members.Add (methodEnd); } return method; }
void GenerateWriteMessage (XmlMembersMapping membersMap) { if (membersMap.HasWrapperElement) { WriteLine ("TopLevelElement ();"); WriteLine ("WriteStartElement (" + GetLiteral (membersMap.ElementName) + ", " + GetLiteral (membersMap.Namespace) + ", (" + GetLiteral(_format == SerializationFormat.Encoded) + "));"); /* WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.Namespace) == null)"); WriteLine ("WriteAttribute (\"xmlns\",\"xsd\",XmlSchema.Namespace,XmlSchema.Namespace);"); Unindent (); WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.InstanceNamespace) == null)"); WriteLine ("WriteAttribute (\"xmlns\",\"xsi\",XmlSchema.InstanceNamespace,XmlSchema.InstanceNamespace);"); Unindent (); */ } GenerateWriteObjectElement (membersMap, "pars", true); if (membersMap.HasWrapperElement) WriteLine ("WriteEndElement();"); }
void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType) { ClassMap cmap = (ClassMap)xmlMembersMapping.ObjectMap; if (xmlMembersMapping.HasWrapperElement && exportEnclosingType) { XmlSchema schema = GetSchema(xmlMembersMapping.Namespace); XmlSchemaComplexType stype = new XmlSchemaComplexType(); XmlSchemaSequence particle; XmlSchemaAnyAttribute anyAttribute; ExportMembersMapSchema(schema, cmap, null, stype.Attributes, out particle, out anyAttribute); stype.Particle = particle; stype.AnyAttribute = anyAttribute; if (encodedFormat) { stype.Name = xmlMembersMapping.ElementName; schema.Items.Add(stype); } else { XmlSchemaElement selem = new XmlSchemaElement(); selem.Name = xmlMembersMapping.ElementName; selem.SchemaType = stype; schema.Items.Add(selem); } } else { ICollection members = cmap.ElementMembers; if (members != null) { foreach (XmlTypeMapMemberElement member in members) { if (member is XmlTypeMapMemberAnyElement && member.TypeData.IsListType) { XmlSchema mschema = GetSchema(xmlMembersMapping.Namespace); XmlSchemaParticle par = GetSchemaArrayElement(mschema, member.ElementInfo); if (par is XmlSchemaAny) { XmlSchemaComplexType ct = FindComplexType(mschema.Items, "any"); if (ct != null) { continue; } ct = new XmlSchemaComplexType(); ct.Name = "any"; ct.IsMixed = true; XmlSchemaSequence seq = new XmlSchemaSequence(); ct.Particle = seq; seq.Items.Add(par); mschema.Items.Add(ct); continue; } } XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo)member.ElementInfo [0]; XmlSchema schema; if (encodedFormat) { schema = GetSchema(xmlMembersMapping.Namespace); ImportNamespace(schema, XmlSerializer.EncodingNamespace); } else { schema = GetSchema(einfo.Namespace); } XmlSchemaElement exe = FindElement(schema.Items, einfo.ElementName); XmlSchemaElement elem; XmlSchemaObjectContainer container = null; // In encoded format, the schema elements are not needed if (!encodedFormat) { container = new XmlSchemaObjectContainer(schema); } Type memType = member.GetType(); if (member is XmlTypeMapMemberFlatList) { throw new InvalidOperationException("Unwrapped arrays not supported as parameters"); } else if (memType == typeof(XmlTypeMapMemberElement)) { elem = (XmlSchemaElement)GetSchemaElement(schema, einfo, member.DefaultValue, false, container); } else { elem = (XmlSchemaElement)GetSchemaElement(schema, einfo, false, container); } if (exe != null) { if (exe.SchemaTypeName.Equals(elem.SchemaTypeName)) { schema.Items.Remove(elem); } else { string s = "The XML element named '" + einfo.ElementName + "' "; s += "from namespace '" + schema.TargetNamespace + "' references distinct types " + elem.SchemaTypeName.Name + " and " + exe.SchemaTypeName.Name + ". "; s += "Use XML attributes to specify another XML name or namespace for the element or types."; throw new InvalidOperationException(s); } } } } } CompileSchemas(); }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType) { _exporter.ExportMembersMapping(xmlMembersMapping, exportEnclosingType); }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { _exporter.ExportMembersMapping(xmlMembersMapping, false); }
string GenerateReadMessage (XmlMembersMapping typeMap) { WriteLine ("object[] parameters = new object[" + typeMap.Count + "];"); WriteLine (""); if (typeMap.HasWrapperElement) { if (_format == SerializationFormat.Encoded) { WriteLine ("while (Reader.NodeType == System.Xml.XmlNodeType.Element)"); WriteLineInd ("{"); WriteLine ("string root = Reader.GetAttribute (\"root\", " + GetLiteral(XmlSerializer.EncodingNamespace) + ");"); WriteLine ("if (root == null || System.Xml.XmlConvert.ToBoolean(root)) break;"); WriteLine ("ReadReferencedElement ();"); WriteLine ("Reader.MoveToContent ();"); WriteLineUni ("}"); WriteLine (""); WriteLine ("if (Reader.NodeType != System.Xml.XmlNodeType.EndElement)"); WriteLineInd ("{"); WriteLineInd ("if (Reader.IsEmptyElement) {"); WriteLine ("Reader.Skip();"); WriteLine ("Reader.MoveToContent();"); WriteLineUni ("}"); WriteLineInd ("else {"); WriteLine ("Reader.ReadStartElement();"); GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false); WriteLine ("ReadEndElement();"); WriteLineUni ("}"); WriteLine (""); WriteLine ("Reader.MoveToContent();"); WriteLineUni ("}"); } else { // bug #79988: out parameters need to be initialized if // they are value types ClassMap classMap = (ClassMap) typeMap.ObjectMap; ArrayList members = classMap.AllMembers; for (int n = 0; n < members.Count; n++) { XmlTypeMapMember mem = (XmlTypeMapMember) members [n]; if (!mem.IsReturnValue && mem.TypeData.IsValueType) GenerateSetMemberValueFromAttr (mem, "parameters", String.Format ("({0}) Activator.CreateInstance(typeof({0}), true)", mem.TypeData.FullTypeName), true); } WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.ReadState == ReadState.Interactive)"); WriteLineInd ("{"); WriteLine ("if (Reader.IsStartElement(" + GetLiteral(typeMap.ElementName) + ", " + GetLiteral(typeMap.Namespace) + "))"); WriteLineInd ("{"); bool dummy = false; GenerateReadAttributeMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, ref dummy); WriteLine ("if (Reader.IsEmptyElement)"); WriteLineInd ("{"); WriteLine ("Reader.Skip(); Reader.MoveToContent(); continue;"); WriteLineUni ("}"); WriteLine ("Reader.ReadStartElement();"); GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false); WriteLine ("ReadEndElement();"); WriteLine ("break;"); WriteLineUni ("}"); WriteLineInd ("else "); WriteLine ("UnknownNode(null);"); Unindent (); WriteLine (""); WriteLine ("Reader.MoveToContent();"); WriteLineUni ("}"); } } else GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, _format == SerializationFormat.Encoded); if (_format == SerializationFormat.Encoded) WriteLine ("ReadReferencedElements();"); return "parameters"; }
/// <include file='doc\SoapReflectionImporter.uex' path='docs/doc[@for="SoapReflectionImporter.ImportMembersMapping3"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access) { ElementAccessor element = new ElementAccessor(); element.IsSoap = true; element.Name = elementName == null || elementName.Length == 0 ? elementName : XmlConvert.EncodeLocalName(elementName); element.Mapping = ImportMembersMapping(members, ns, hasWrapperElement, writeAccessors, validate); element.Mapping.TypeName = elementName; element.Namespace = element.Mapping.Namespace == null ? ns : element.Mapping.Namespace; element.Form = XmlSchemaForm.Qualified; XmlMembersMapping xmlMapping = new XmlMembersMapping(typeScope, element, access); xmlMapping.IsSoap = true; xmlMapping.GenerateSerializer = true; return xmlMapping; }
// // 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); }
/// <summary>Adds an element declaration to the applicable <see cref="T:System.Xml.Schema.XmlSchema" /> for each of the element parts of a literal SOAP message definition, and specifies whether enclosing elements are included.</summary> /// <param name="xmlMembersMapping">The internal mapping between a .NET Framework type and an XML schema element.</param> /// <param name="exportEnclosingType">true if the schema elements that enclose the schema are to be included; otherwise, false.</param> public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType) { ClassMap classMap = (ClassMap)xmlMembersMapping.ObjectMap; if (xmlMembersMapping.HasWrapperElement && exportEnclosingType) { XmlSchema schema = this.GetSchema(xmlMembersMapping.Namespace); XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType(); XmlSchemaSequence particle; XmlSchemaAnyAttribute anyAttribute; this.ExportMembersMapSchema(schema, classMap, null, xmlSchemaComplexType.Attributes, out particle, out anyAttribute); xmlSchemaComplexType.Particle = particle; xmlSchemaComplexType.AnyAttribute = anyAttribute; if (this.encodedFormat) { xmlSchemaComplexType.Name = xmlMembersMapping.ElementName; schema.Items.Add(xmlSchemaComplexType); } else { XmlSchemaElement xmlSchemaElement = new XmlSchemaElement(); xmlSchemaElement.Name = xmlMembersMapping.ElementName; xmlSchemaElement.SchemaType = xmlSchemaComplexType; schema.Items.Add(xmlSchemaElement); } } else { ICollection elementMembers = classMap.ElementMembers; if (elementMembers != null) { foreach (object obj in elementMembers) { XmlTypeMapMemberElement xmlTypeMapMemberElement = (XmlTypeMapMemberElement)obj; if (xmlTypeMapMemberElement is XmlTypeMapMemberAnyElement && xmlTypeMapMemberElement.TypeData.IsListType) { XmlSchema schema2 = this.GetSchema(xmlMembersMapping.Namespace); XmlSchemaParticle schemaArrayElement = this.GetSchemaArrayElement(schema2, xmlTypeMapMemberElement.ElementInfo); if (schemaArrayElement is XmlSchemaAny) { XmlSchemaComplexType xmlSchemaComplexType2 = this.FindComplexType(schema2.Items, "any"); if (xmlSchemaComplexType2 != null) { continue; } xmlSchemaComplexType2 = new XmlSchemaComplexType(); xmlSchemaComplexType2.Name = "any"; xmlSchemaComplexType2.IsMixed = true; XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence(); xmlSchemaComplexType2.Particle = xmlSchemaSequence; xmlSchemaSequence.Items.Add(schemaArrayElement); schema2.Items.Add(xmlSchemaComplexType2); continue; } } XmlTypeMapElementInfo xmlTypeMapElementInfo = (XmlTypeMapElementInfo)xmlTypeMapMemberElement.ElementInfo[0]; XmlSchema schema3; if (this.encodedFormat) { schema3 = this.GetSchema(xmlMembersMapping.Namespace); this.ImportNamespace(schema3, "http://schemas.xmlsoap.org/soap/encoding/"); } else { schema3 = this.GetSchema(xmlTypeMapElementInfo.Namespace); } XmlSchemaElement xmlSchemaElement2 = this.FindElement(schema3.Items, xmlTypeMapElementInfo.ElementName); XmlSchemaExporter.XmlSchemaObjectContainer container = null; if (!this.encodedFormat) { container = new XmlSchemaExporter.XmlSchemaObjectContainer(schema3); } Type type = xmlTypeMapMemberElement.GetType(); if (xmlTypeMapMemberElement is XmlTypeMapMemberFlatList) { throw new InvalidOperationException("Unwrapped arrays not supported as parameters"); } XmlSchemaElement xmlSchemaElement3; if (type == typeof(XmlTypeMapMemberElement)) { xmlSchemaElement3 = (XmlSchemaElement)this.GetSchemaElement(schema3, xmlTypeMapElementInfo, xmlTypeMapMemberElement.DefaultValue, false, container); } else { xmlSchemaElement3 = (XmlSchemaElement)this.GetSchemaElement(schema3, xmlTypeMapElementInfo, false, container); } if (xmlSchemaElement2 != null) { if (!xmlSchemaElement2.SchemaTypeName.Equals(xmlSchemaElement3.SchemaTypeName)) { string text = "The XML element named '" + xmlTypeMapElementInfo.ElementName + "' "; string text2 = text; text = string.Concat(new string[] { text2, "from namespace '", schema3.TargetNamespace, "' references distinct types ", xmlSchemaElement3.SchemaTypeName.Name, " and ", xmlSchemaElement2.SchemaTypeName.Name, ". " }); text += "Use XML attributes to specify another XML name or namespace for the element or types."; throw new InvalidOperationException(text); } schema3.Items.Remove(xmlSchemaElement3); } } } } this.CompileSchemas(); }
void GenerateMemberAttributes (XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeParameterDeclarationExpression param) { if (use == SoapBindingUse.Literal) xmlExporter.AddMappingMetadata (param.CustomAttributes, member, members.Namespace); else soapExporter.AddMappingMetadata (param.CustomAttributes, member); }
public string ExportAnyType(XmlMembersMapping members) { if (((members.Count != 1) || !members[0].Any) || (members[0].ElementName.Length != 0)) { return null; } XmlMemberMapping mapping = members[0]; string ns = mapping.Namespace; bool isArrayLike = mapping.Mapping.TypeDesc.IsArrayLike; bool mixed = (isArrayLike && (mapping.Mapping.TypeDesc.ArrayElementTypeDesc != null)) ? mapping.Mapping.TypeDesc.ArrayElementTypeDesc.IsMixed : mapping.Mapping.TypeDesc.IsMixed; if (mixed && mapping.Mapping.TypeDesc.IsMixed) { isArrayLike = true; } string str2 = mixed ? "any" : (isArrayLike ? "anyElements" : "anyElement"); string name = str2; int num = 0; XmlSchema schema = this.schemas[ns]; if (schema != null) { while (true) { XmlSchemaType schemaType = FindSchemaType(name, schema.Items); if (schemaType == null) { break; } if (IsAnyType(schemaType, mixed, isArrayLike)) { return name; } num++; name = str2 + num.ToString(CultureInfo.InvariantCulture); } } XmlSchemaComplexType item = new XmlSchemaComplexType { Name = name, IsMixed = mixed }; XmlSchemaSequence sequence = new XmlSchemaSequence(); XmlSchemaAny any = new XmlSchemaAny { MinOccurs = 0M }; if (isArrayLike) { any.MaxOccurs = 79228162514264337593543950335M; } sequence.Items.Add(any); item.Particle = sequence; this.AddSchemaItem(item, ns, null); return name; }
XmlMembersMapping ImportMembersMapping (string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access) { // Reset (); Disabled. See ChangeLog ArrayList mapping = new ArrayList (); for (int n=0; n<members.Length; n++) { if (members[n].XmlAttributes.XmlIgnore) continue; XmlTypeMapMember mapMem = CreateMapMember (null, members[n], ns); mapMem.GlobalIndex = n; mapMem.CheckOptionalValueType (members); mapping.Add (new XmlMemberMapping (members[n].MemberName, ns, mapMem, false)); } elementName = XmlConvert.EncodeLocalName (elementName); XmlMembersMapping mps = new XmlMembersMapping (elementName, ns, hasWrapperElement, false, (XmlMemberMapping[])mapping.ToArray (typeof(XmlMemberMapping))); mps.RelatedMaps = relatedMaps; mps.Format = SerializationFormat.Literal; Type[] extraTypes = includedTypes != null ? (Type[])includedTypes.ToArray(typeof(Type)) : null; #if !NET_2_1 mps.Source = new MembersSerializationSource (elementName, hasWrapperElement, members, false, true, ns, extraTypes); if (allowPrivateTypes) mps.Source.CanBeGenerated = false; #endif return mps; }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { this.ExportMembersMapping(xmlMembersMapping, true); }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType) { xmlMembersMapping.CheckShallow(); MembersMapping mapping = (MembersMapping) xmlMembersMapping.Accessor.Mapping; this.CheckScope(xmlMembersMapping.Scope); if (mapping.HasWrapperElement && exportEnclosingType) { this.ExportElement(xmlMembersMapping.Accessor); } else { foreach (MemberMapping mapping2 in mapping.Members) { if (mapping2.Attribute != null) { throw new InvalidOperationException(Res.GetString("XmlBareAttributeMember", new object[] { mapping2.Attribute.Name })); } if (mapping2.Text != null) { throw new InvalidOperationException(Res.GetString("XmlBareTextMember", new object[] { mapping2.Text.Name })); } if ((mapping2.Elements != null) && (mapping2.Elements.Length != 0)) { if (mapping2.TypeDesc.IsArrayLike && !(mapping2.Elements[0].Mapping is ArrayMapping)) { throw new InvalidOperationException(Res.GetString("XmlIllegalArrayElement", new object[] { mapping2.Elements[0].Name })); } if (exportEnclosingType) { this.ExportElement(mapping2.Elements[0]); } else { this.ExportMapping(mapping2.Elements[0].Mapping, mapping2.Elements[0].Namespace, mapping2.Elements[0].Any); } } } } this.ExportRootIfNecessary(xmlMembersMapping.Scope); }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { CodeTypeDeclaration dummyClass = new CodeTypeDeclaration(); ExportMembersMapCode(dummyClass, (ClassMap)xmlMembersMapping.ObjectMap, xmlMembersMapping.Namespace, null); }
void CreateLiteralMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped, bool rpc) { if (members.Count == 1 && members[0].Any && members[0].ElementName.Length == 0 && !wrapped) { string typeName = SchemaExporter.ExportAnyType(members[0].Namespace); MessagePart part = new MessagePart(); part.Name = members[0].MemberName; part.Type = new XmlQualifiedName(typeName, members[0].Namespace); message.Parts.Add(part); } else { SchemaExporter.ExportMembersMapping(members, !rpc); if (wrapped) { MessagePart part = new MessagePart(); part.Name = "parameters"; part.Element = new XmlQualifiedName(members.XsdElementName, members.Namespace); message.Parts.Add(part); } else { for (int i = 0; i < members.Count; i++) { XmlMemberMapping member = members[i]; MessagePart part = new MessagePart(); if (rpc) { // Generate massage part with the type attribute if (member.TypeName == null || member.TypeName.Length == 0) { throw new InvalidOperationException(Res.GetString(Res.WsdlGenRpcLitAnonimousType, Method.DeclaringType.Name, Method.Name, member.MemberName)); } part.Name = member.XsdElementName; part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace); } else { part.Name = XmlConvert.EncodeLocalName(member.MemberName); part.Element = new XmlQualifiedName(member.XsdElementName, member.Namespace); } message.Parts.Add(part); } } } messageBinding.Extensions.Add(CreateSoapBodyBinding(SoapBindingUse.Literal, rpc ? members.Namespace : null)); }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { codeGenerator.ExportMembersMapping(xmlMembersMapping); }
string GenerateMembersElement(XmlMembersMapping xmlMembersMapping) { if (xmlMembersMapping.Accessor.IsSoap) return GenerateEncodedMembersElement(xmlMembersMapping); else return GenerateLiteralMembersElement(xmlMembersMapping); }
public XmlQualifiedName ExportTypeMapping(XmlMembersMapping xmlMembersMapping) { throw new NotImplementedException(); }
string GenerateEncodedMembersElement(XmlMembersMapping xmlMembersMapping) { ElementAccessor element = xmlMembersMapping.Accessor; MembersMapping membersMapping = (MembersMapping)element.Mapping; MemberMapping[] mappings = membersMapping.Members; bool hasWrapperElement = membersMapping.HasWrapperElement; bool writeAccessors = membersMapping.WriteAccessors; string methodName = NextMethodName(element.Name); Writer.WriteLine(); Writer.Write("public object[] "); Writer.Write(methodName); Writer.WriteLine("() {"); Writer.Indent++; Writer.WriteLine("Reader.MoveToContent();"); Writer.Write("object[] p = new object["); Writer.Write(mappings.Length.ToString(CultureInfo.InvariantCulture)); Writer.WriteLine("];"); InitializeValueTypes("p", mappings); if (hasWrapperElement) { WriteReadNonRoots(); if (membersMapping.ValidateRpcWrapperElement) { Writer.Write("if (!"); WriteXmlNodeEqual("Reader", element.Name, element.Form == XmlSchemaForm.Qualified ? element.Namespace : ""); Writer.WriteLine(") throw CreateUnknownNodeException();"); } Writer.WriteLine("bool isEmptyWrapper = Reader.IsEmptyElement;"); Writer.WriteLine("Reader.ReadStartElement();"); } Member[] members = new Member[mappings.Length]; for (int i = 0; i < mappings.Length; i++) { MemberMapping mapping = mappings[i]; string source = "p[" + i.ToString(CultureInfo.InvariantCulture) + "]"; string arraySource = source; if (mapping.Xmlns != null) { arraySource = "((" + mapping.TypeDesc.CSharpName + ")" + source + ")"; } Member member = new Member(this,source, arraySource, "a", i, mapping); if (!mapping.IsSequence) member.ParamsReadSource = "paramsRead[" + i.ToString(CultureInfo.InvariantCulture) + "]"; members[i] = member; if (mapping.CheckSpecified == SpecifiedAccessor.ReadWrite) { string nameSpecified = mapping.Name + "Specified"; for (int j = 0; j < mappings.Length; j++) { if (mappings[j].Name == nameSpecified) { member.CheckSpecifiedSource = "p[" + j.ToString(CultureInfo.InvariantCulture) + "]"; break; } } } } string fixupMethodName = "fixup_" + methodName; bool anyFixups = WriteMemberFixupBegin(members, fixupMethodName, "p"); if (members.Length > 0 && members[0].Mapping.IsReturnValue) Writer.WriteLine("IsReturnValue = true;"); string checkTypeHrefSource = (!hasWrapperElement && !writeAccessors) ? "hrefList" : null; if (checkTypeHrefSource != null) WriteInitCheckTypeHrefList(checkTypeHrefSource); WriteParamsRead(mappings.Length); int loopIndex = WriteWhileNotLoopStart(); Writer.Indent++; string unrecognizedElementSource = checkTypeHrefSource == null ? "UnknownNode((object)p);" : "if (Reader.GetAttribute(\"id\", null) != null) { ReadReferencedElement(); } else { UnknownNode((object)p); }"; WriteMemberElements(members, unrecognizedElementSource, "UnknownNode((object)p);", null, null, checkTypeHrefSource); Writer.WriteLine("Reader.MoveToContent();"); WriteWhileLoopEnd(loopIndex); if (hasWrapperElement) Writer.WriteLine("if (!isEmptyWrapper) ReadEndElement();"); if (checkTypeHrefSource != null) WriteHandleHrefList(members, checkTypeHrefSource); Writer.WriteLine("ReadReferencedElements();"); Writer.WriteLine("return p;"); Writer.Indent--; Writer.WriteLine("}"); if (anyFixups) WriteFixupMethod(fixupMethodName, members, "object[]", false, false, "p"); return methodName; }
public string ExportAnyType(XmlMembersMapping members) { throw new NotImplementedException(); }
public void ExportMembersMapping (XmlMembersMapping xmlMembersMapping) { codeGenerator.ExportMembersMapping (xmlMembersMapping); }
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping) { this.ExportMembersMapping(xmlMembersMapping, false); }
string GenerateMembersElement(XmlMembersMapping xmlMembersMapping) { ElementAccessor element = xmlMembersMapping.Accessor; MembersMapping mapping = (MembersMapping)element.Mapping; bool hasWrapperElement = mapping.HasWrapperElement; bool writeAccessors = mapping.WriteAccessors; bool isRpc = xmlMembersMapping.IsSoap && writeAccessors; string methodName = NextMethodName(element.Name); Writer.WriteLine(); Writer.Write("public void "); Writer.Write(methodName); Writer.WriteLine("(object[] p) {"); Writer.Indent++; Writer.WriteLine("WriteStartDocument();"); if (!mapping.IsSoap) { Writer.WriteLine("TopLevelElement();"); } // in the top-level method add check for the parameters length, // because visual basic does not have a concept of an <out> parameter it uses <ByRef> instead // so sometime we think that we have more parameters then supplied Writer.WriteLine("int pLength = p.Length;"); if (hasWrapperElement) { WriteStartElement(element.Name, (element.Form == XmlSchemaForm.Qualified ? element.Namespace : ""), mapping.IsSoap); int xmlnsMember = FindXmlnsIndex(mapping.Members); if (xmlnsMember >= 0) { MemberMapping member = mapping.Members[xmlnsMember]; string source = "((" + typeof(XmlSerializerNamespaces).FullName + ")p[" + xmlnsMember.ToString(CultureInfo.InvariantCulture) + "])"; Writer.Write("if (pLength > "); Writer.Write(xmlnsMember.ToString(CultureInfo.InvariantCulture)); Writer.WriteLine(") {"); Writer.Indent++; WriteNamespaces(source); Writer.Indent--; Writer.WriteLine("}"); } for (int i = 0; i < mapping.Members.Length; i++) { MemberMapping member = mapping.Members[i]; if (member.Attribute != null && !member.Ignore) { string source = "p[" + i.ToString(CultureInfo.InvariantCulture) + "]"; string specifiedSource = null; int specifiedPosition = 0; if (member.CheckSpecified != SpecifiedAccessor.None) { string memberNameSpecified = member.Name + "Specified"; for (int j = 0; j < mapping.Members.Length; j++) { if (mapping.Members[j].Name == memberNameSpecified) { specifiedSource = "((bool) p[" + j.ToString(CultureInfo.InvariantCulture) + "])"; specifiedPosition = j; break; } } } Writer.Write("if (pLength > "); Writer.Write(i.ToString(CultureInfo.InvariantCulture)); Writer.WriteLine(") {"); Writer.Indent++; if (specifiedSource != null) { Writer.Write("if (pLength <= "); Writer.Write(specifiedPosition.ToString(CultureInfo.InvariantCulture)); Writer.Write(" || "); Writer.Write(specifiedSource); Writer.WriteLine(") {"); Writer.Indent++; } WriteMember(source, member.Attribute, member.TypeDesc, "p"); if (specifiedSource != null) { Writer.Indent--; Writer.WriteLine("}"); } Writer.Indent--; Writer.WriteLine("}"); } } } for (int i = 0; i < mapping.Members.Length; i++) { MemberMapping member = mapping.Members[i]; if (member.Xmlns != null) continue; if (member.Ignore) continue; string specifiedSource = null; int specifiedPosition = 0; if (member.CheckSpecified != SpecifiedAccessor.None) { string memberNameSpecified = member.Name + "Specified"; for (int j = 0; j < mapping.Members.Length; j++) { if (mapping.Members[j].Name == memberNameSpecified) { specifiedSource = "((bool) p[" + j.ToString(CultureInfo.InvariantCulture) + "])"; specifiedPosition = j; break; } } } Writer.Write("if (pLength > "); Writer.Write(i.ToString(CultureInfo.InvariantCulture)); Writer.WriteLine(") {"); Writer.Indent++; if (specifiedSource != null) { Writer.Write("if (pLength <= "); Writer.Write(specifiedPosition.ToString(CultureInfo.InvariantCulture)); Writer.Write(" || "); Writer.Write(specifiedSource); Writer.WriteLine(") {"); Writer.Indent++; } string source = "p[" + i.ToString(CultureInfo.InvariantCulture) + "]"; string enumSource = null; if (member.ChoiceIdentifier != null) { for (int j = 0; j < mapping.Members.Length; j++) { if (mapping.Members[j].Name == member.ChoiceIdentifier.MemberName) { if (member.ChoiceIdentifier.Mapping.TypeDesc.UseReflection) enumSource = "p[" + j.ToString(CultureInfo.InvariantCulture) + "]"; else enumSource = "((" + mapping.Members[j].TypeDesc.CSharpName + ")p[" + j.ToString(CultureInfo.InvariantCulture) + "]" + ")"; break; } } #if DEBUG // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (enumSource == null) throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Can not find " + member.ChoiceIdentifier.MemberName + " in the members mapping.")); #endif } if (isRpc && member.IsReturnValue && member.Elements.Length > 0) { Writer.Write("WriteRpcResult("); WriteQuotedCSharpString(member.Elements[0].Name); Writer.Write(", "); WriteQuotedCSharpString(""); Writer.WriteLine(");"); } // override writeAccessors choice when we've written a wrapper element WriteMember(source, enumSource, member.ElementsSortedByDerivation, member.Text, member.ChoiceIdentifier, member.TypeDesc, writeAccessors || hasWrapperElement); if (specifiedSource != null) { Writer.Indent--; Writer.WriteLine("}"); } Writer.Indent--; Writer.WriteLine("}"); } if (hasWrapperElement) { WriteEndElement(); } if (element.IsSoap) { if (!hasWrapperElement && !writeAccessors) { // doc/bare case -- allow extra members Writer.Write("if (pLength > "); Writer.Write(mapping.Members.Length.ToString(CultureInfo.InvariantCulture)); Writer.WriteLine(") {"); Writer.Indent++; WriteExtraMembers(mapping.Members.Length.ToString(CultureInfo.InvariantCulture), "pLength"); Writer.Indent--; Writer.WriteLine("}"); } Writer.WriteLine("WriteReferencedElements();"); } Writer.Indent--; Writer.WriteLine("}"); return methodName; }
public XmlQualifiedName ExportTypeMapping(XmlMembersMapping xmlMembersMapping) { xmlMembersMapping.CheckShallow(); this.CheckScope(xmlMembersMapping.Scope); MembersMapping mapping = (MembersMapping) xmlMembersMapping.Accessor.Mapping; if ((mapping.Members.Length != 1) || !(mapping.Members[0].Elements[0].Mapping is SpecialMapping)) { return null; } SpecialMapping mapping2 = (SpecialMapping) mapping.Members[0].Elements[0].Mapping; XmlSchemaType item = this.ExportSpecialMapping(mapping2, xmlMembersMapping.Accessor.Namespace, false, null); if (((item != null) && (item.Name != null)) && (item.Name.Length > 0)) { item.Name = xmlMembersMapping.Accessor.Name; this.AddSchemaItem(item, xmlMembersMapping.Accessor.Namespace, null); } this.ExportRootIfNecessary(xmlMembersMapping.Scope); return new XmlQualifiedName(xmlMembersMapping.Accessor.Name, xmlMembersMapping.Accessor.Namespace); }