void AddElementFieldMember(CodeTypeDeclaration codeClass, XmlTypeMapMemberElement member, string defaultNamespace) { CodeMemberField codeField = CreateFieldMember(member); codeClass.Members.Add(codeField); CodeAttributeDeclarationCollection attributes = codeField.CustomAttributes; if (attributes == null) { attributes = new CodeAttributeDeclarationCollection(); } AddElementMemberAttributes(member, defaultNamespace, attributes, false); if (attributes.Count > 0) { codeField.CustomAttributes = attributes; } if (member.TypeData.IsValueType && member.IsOptionalValueType) { codeField = new CodeMemberField(typeof(bool), member.Name + "Specified"); codeField.Attributes = MemberAttributes.Public; codeClass.Members.Add(codeField); GenerateSpecifierMember(codeField); } }
void ImportTextElementInfo(XmlTypeMapElementInfoList list, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts) { if (atts.XmlText != null) { member.IsXmlTextCollector = true; if (atts.XmlText.Type != null) { defaultType = atts.XmlText.Type; } if (defaultType == typeof(XmlNode)) { defaultType = typeof(XmlText); // Nodes must be text nodes } XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(member, TypeTranslator.GetTypeData(defaultType, atts.XmlText.DataType)); if (elem.TypeData.SchemaType != SchemaTypes.Primitive && elem.TypeData.SchemaType != SchemaTypes.Enum && elem.TypeData.SchemaType != SchemaTypes.XmlNode && !(elem.TypeData.SchemaType == SchemaTypes.Array && elem.TypeData.ListItemTypeData.SchemaType == SchemaTypes.XmlNode) ) { throw new InvalidOperationException("XmlText cannot be used to encode complex types"); } elem.IsTextElement = true; elem.WrappedElement = false; list.Add(elem); } }
public void AddElementMemberAttributes(XmlTypeMapMemberElement member, string defaultNamespace, CodeAttributeDeclarationCollection attributes, bool forceUseMemberName) { TypeData defaultType = member.TypeData; bool addAlwaysAttr = false; if (member is XmlTypeMapMemberFlatList) { defaultType = defaultType.ListItemTypeData; addAlwaysAttr = true; } foreach (XmlTypeMapElementInfo einfo in member.ElementInfo) { if (einfo.MappedType != null) { ExportMapCode(einfo.MappedType, false); RemoveInclude(einfo.MappedType); } if (ExportExtraElementAttributes(attributes, einfo, defaultNamespace, defaultType)) { continue; } GenerateElementInfoMember(attributes, member, einfo, defaultType, defaultNamespace, addAlwaysAttr, forceUseMemberName | addAlwaysAttr); } GenerateElementMember(attributes, member); }
void AddAnyElementFieldMember(CodeTypeDeclaration codeClass, XmlTypeMapMemberElement member, string defaultNamespace) { CodeTypeMember codeField = CreateFieldMember(codeClass, member); CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection(); foreach (XmlTypeMapElementInfo einfo in member.ElementInfo) { ExportExtraElementAttributes(attributes, einfo, defaultNamespace, einfo.TypeData); } if (attributes.Count > 0) { codeField.CustomAttributes = attributes; } }
private void WriteElementMembers(ClassMap map, object ob, bool isValueList) { ICollection elementMembers = map.ElementMembers; if (elementMembers != null) { foreach (object obj in elementMembers) { XmlTypeMapMemberElement xmlTypeMapMemberElement = (XmlTypeMapMemberElement)obj; if (this.MemberHasValue(xmlTypeMapMemberElement, ob, isValueList)) { object memberValue = this.GetMemberValue(xmlTypeMapMemberElement, ob, isValueList); Type type = xmlTypeMapMemberElement.GetType(); if (type == typeof(XmlTypeMapMemberList)) { this.WriteMemberElement((XmlTypeMapElementInfo)xmlTypeMapMemberElement.ElementInfo[0], memberValue); } else if (type == typeof(XmlTypeMapMemberFlatList)) { if (memberValue != null) { this.WriteListContent(ob, xmlTypeMapMemberElement.TypeData, ((XmlTypeMapMemberFlatList)xmlTypeMapMemberElement).ListMap, memberValue, null); } } else if (type == typeof(XmlTypeMapMemberAnyElement)) { if (memberValue != null) { this.WriteAnyElementContent((XmlTypeMapMemberAnyElement)xmlTypeMapMemberElement, memberValue); } } else if (type != typeof(XmlTypeMapMemberAnyAttribute)) { if (type != typeof(XmlTypeMapMemberElement)) { throw new InvalidOperationException("Unknown member type"); } XmlTypeMapElementInfo elem = xmlTypeMapMemberElement.FindElement(ob, memberValue); this.WriteMemberElement(elem, memberValue); } } } } }
public XmlTypeMapElementInfo GetElement(int index) { if (this._elements == null) { return(null); } if (this._elementsByIndex == null) { this._elementsByIndex = new XmlTypeMapElementInfo[this._elementMembers.Count]; foreach (object obj in this._elementMembers) { XmlTypeMapMemberElement xmlTypeMapMemberElement = (XmlTypeMapMemberElement)obj; if (xmlTypeMapMemberElement.ElementInfo.Count != 1) { throw new InvalidOperationException("Read by order only possible for encoded/bare format"); } this._elementsByIndex[xmlTypeMapMemberElement.Index] = (XmlTypeMapElementInfo)xmlTypeMapMemberElement.ElementInfo[0]; } } return(this._elementsByIndex[index]); }
protected override void GenerateArrayElement (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName) { XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) member.ElementInfo[0]; CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlArray"); if (forceUseMemberName || (einfo.ElementName != member.Name)) att.Arguments.Add (GetArg ("ElementName", einfo.ElementName)); if (einfo.Namespace != defaultNamespace) att.Arguments.Add (GetArg ("Namespace", einfo.Namespace)); if (einfo.Form == XmlSchemaForm.Unqualified) att.Arguments.Add (MapCodeGenerator.GetEnumArg ("Form", "System.Xml.Schema.XmlSchemaForm", einfo.Form.ToString())); if (einfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", true)); if (att.Arguments.Count > 0) attributes.Add (att); }
private XmlTypeMapMember CreateMapMember(XmlReflectionMember rmember, string defaultNamespace) { SoapAttributes soapAttributes = rmember.SoapAttributes; TypeData typeData = TypeTranslator.GetTypeData(rmember.MemberType); XmlTypeMapMember xmlTypeMapMember; if (soapAttributes.SoapAttribute != null) { if (typeData.SchemaType != SchemaTypes.Enum && typeData.SchemaType != SchemaTypes.Primitive) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot serialize member '{0}' of type {1}. SoapAttribute cannot be used to encode complex types.", new object[] { rmember.MemberName, typeData.FullTypeName })); } if (soapAttributes.SoapElement != null) { throw new Exception("SoapAttributeAttribute and SoapElementAttribute cannot be applied to the same member"); } XmlTypeMapMemberAttribute xmlTypeMapMemberAttribute = new XmlTypeMapMemberAttribute(); if (soapAttributes.SoapAttribute.AttributeName.Length == 0) { xmlTypeMapMemberAttribute.AttributeName = XmlConvert.EncodeLocalName(rmember.MemberName); } else { xmlTypeMapMemberAttribute.AttributeName = XmlConvert.EncodeLocalName(soapAttributes.SoapAttribute.AttributeName); } xmlTypeMapMemberAttribute.Namespace = ((soapAttributes.SoapAttribute.Namespace == null) ? string.Empty : soapAttributes.SoapAttribute.Namespace); if (typeData.IsComplexType) { xmlTypeMapMemberAttribute.MappedType = this.ImportTypeMapping(typeData.Type, defaultNamespace); } typeData = TypeTranslator.GetTypeData(rmember.MemberType, soapAttributes.SoapAttribute.DataType); xmlTypeMapMember = xmlTypeMapMemberAttribute; xmlTypeMapMember.DefaultValue = this.GetDefaultValue(typeData, soapAttributes.SoapDefaultValue); } else { if (typeData.SchemaType == SchemaTypes.Array) { xmlTypeMapMember = new XmlTypeMapMemberList(); } else { xmlTypeMapMember = new XmlTypeMapMemberElement(); } if (soapAttributes.SoapElement != null && soapAttributes.SoapElement.DataType.Length != 0) { typeData = TypeTranslator.GetTypeData(rmember.MemberType, soapAttributes.SoapElement.DataType); } XmlTypeMapElementInfoList xmlTypeMapElementInfoList = new XmlTypeMapElementInfoList(); XmlTypeMapElementInfo xmlTypeMapElementInfo = new XmlTypeMapElementInfo(xmlTypeMapMember, typeData); xmlTypeMapElementInfo.ElementName = XmlConvert.EncodeLocalName((soapAttributes.SoapElement == null || soapAttributes.SoapElement.ElementName.Length == 0) ? rmember.MemberName : soapAttributes.SoapElement.ElementName); xmlTypeMapElementInfo.Namespace = string.Empty; xmlTypeMapElementInfo.IsNullable = (soapAttributes.SoapElement != null && soapAttributes.SoapElement.IsNullable); if (typeData.IsComplexType) { xmlTypeMapElementInfo.MappedType = this.ImportTypeMapping(typeData.Type, defaultNamespace); } xmlTypeMapElementInfoList.Add(xmlTypeMapElementInfo); ((XmlTypeMapMemberElement)xmlTypeMapMember).ElementInfo = xmlTypeMapElementInfoList; } xmlTypeMapMember.TypeData = typeData; xmlTypeMapMember.Name = rmember.MemberName; xmlTypeMapMember.IsReturnValue = rmember.IsReturnValue; return(xmlTypeMapMember); }
private XmlTypeMapMember CreateMapMember(XmlReflectionMember rmember, string defaultNamespace) { XmlTypeMapMember mapMember; XmlAttributes atts = rmember.XmlAttributes; TypeData typeData = TypeTranslator.GetTypeData(rmember.MemberType); if (atts.XmlAnyAttribute != null) { if ((rmember.MemberType.FullName == "System.Xml.XmlAttribute[]") || (rmember.MemberType.FullName == "System.Xml.XmlNode[]")) { mapMember = new XmlTypeMapMemberAnyAttribute(); } else { throw new InvalidOperationException("XmlAnyAttributeAttribute can only be applied to members of type XmlAttribute[] or XmlNode[]"); } } else if (atts.XmlAnyElements != null && atts.XmlAnyElements.Count > 0) { if ((rmember.MemberType.FullName == "System.Xml.XmlElement[]") || (rmember.MemberType.FullName == "System.Xml.XmlNode[]") || (rmember.MemberType.FullName == "System.Xml.XmlElement")) { XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement(); member.ElementInfo = ImportAnyElementInfo(defaultNamespace, rmember, member, atts); mapMember = member; } else { throw new InvalidOperationException("XmlAnyElementAttribute can only be applied to members of type XmlElement, XmlElement[] or XmlNode[]"); } } else if (atts.Xmlns) { XmlTypeMapMemberNamespaces mapNamespaces = new XmlTypeMapMemberNamespaces(); mapMember = mapNamespaces; } else if (atts.XmlAttribute != null) { // An attribute if (atts.XmlElements != null && atts.XmlElements.Count > 0) { throw new Exception("XmlAttributeAttribute and XmlElementAttribute cannot be applied to the same member"); } XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute(); if (atts.XmlAttribute.AttributeName == null) { mapAttribute.AttributeName = rmember.MemberName; } else { mapAttribute.AttributeName = atts.XmlAttribute.AttributeName; } if (typeData.IsComplexType) { mapAttribute.MappedType = ImportTypeMapping(typeData.Type, null, mapAttribute.Namespace); } if (atts.XmlAttribute.Namespace != null && atts.XmlAttribute.Namespace != defaultNamespace) { if (atts.XmlAttribute.Form == XmlSchemaForm.Unqualified) { throw new InvalidOperationException("The Form property may not be 'Unqualified' when an explicit Namespace property is present"); } mapAttribute.Form = XmlSchemaForm.Qualified; mapAttribute.Namespace = atts.XmlAttribute.Namespace; } else { mapAttribute.Form = atts.XmlAttribute.Form; if (atts.XmlAttribute.Form == XmlSchemaForm.Qualified) { mapAttribute.Namespace = defaultNamespace; } else { mapAttribute.Namespace = ""; } } typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.XmlAttribute.DataType); mapMember = mapAttribute; } else if (typeData.SchemaType == SchemaTypes.Array) { // If the member has a single XmlElementAttribute and the type is the type of the member, // then it is not a flat list if (atts.XmlElements.Count > 1 || (atts.XmlElements.Count == 1 && atts.XmlElements[0].Type != typeData.Type) || (atts.XmlText != null)) { // A flat list // TODO: check that it does not have XmlArrayAttribute XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList(); member.ListMap = new ListMap(); member.ListMap.ItemInfo = ImportElementInfo(rmember.MemberName, defaultNamespace, typeData.ListItemType, member, atts); member.ElementInfo = member.ListMap.ItemInfo; mapMember = member; } else { // A list XmlTypeMapMemberList member = new XmlTypeMapMemberList(); // Creates an ElementInfo that identifies the array instance. member.ElementInfo = new XmlTypeMapElementInfoList(); XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(member, typeData); elem.ElementName = (atts.XmlArray != null && atts.XmlArray.ElementName != null) ? atts.XmlArray.ElementName : rmember.MemberName; elem.Namespace = (atts.XmlArray != null && atts.XmlArray.Namespace != null) ? atts.XmlArray.Namespace : defaultNamespace; elem.MappedType = ImportListMapping(rmember.MemberType, null, elem.Namespace, atts, 0); elem.IsNullable = (atts.XmlArray != null) ? atts.XmlArray.IsNullable : false; elem.Form = (atts.XmlArray != null) ? atts.XmlArray.Form : XmlSchemaForm.Qualified; member.ElementInfo.Add(elem); mapMember = member; } } else { // An element XmlTypeMapMemberElement member = new XmlTypeMapMemberElement(); member.ElementInfo = ImportElementInfo(rmember.MemberName, defaultNamespace, rmember.MemberType, member, atts); mapMember = member; } mapMember.DefaultValue = atts.XmlDefaultValue; mapMember.TypeData = typeData; mapMember.Name = rmember.MemberName; mapMember.IsReturnValue = rmember.IsReturnValue; return(mapMember); }
protected override void GenerateElementInfoMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName) { CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlElementAttribute"); if (forceUseMemberName || einfo.ElementName != member.Name) att.Arguments.Add (GetArg (einfo.ElementName)); if (einfo.TypeData.FullTypeName != defaultType.FullTypeName) att.Arguments.Add (GetTypeArg ("Type", einfo.TypeData.FullTypeName)); if (einfo.Namespace != defaultNamespace) att.Arguments.Add (GetArg ("Namespace", einfo.Namespace)); if (einfo.Form == XmlSchemaForm.Unqualified) att.Arguments.Add (GetEnumArg ("Form", "System.Xml.Schema.XmlSchemaForm", einfo.Form.ToString())); if (einfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", true)); if (!TypeTranslator.IsDefaultPrimitiveTpeData(einfo.TypeData)) att.Arguments.Add (GetArg ("DataType",einfo.TypeData.XmlType)); if (addAlwaysAttr || att.Arguments.Count > 0) attributes.Add (att); }
void ReadMembers(ClassMap map, object ob, bool isValueList, bool readByOrder) { // Set the default values of the members if (map.MembersWithDefault != null) { ArrayList members = map.MembersWithDefault; for (int n = 0; n < members.Count; n++) { XmlTypeMapMember mem = (XmlTypeMapMember)members[n]; SetMemberValueFromAttr(mem, ob, mem.DefaultValue, isValueList); } } // Reads attributes XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember; int anyAttributeIndex = 0; object anyAttributeArray = null; while (Reader.MoveToNextAttribute()) { XmlTypeMapMemberAttribute member = map.GetAttribute(Reader.LocalName, Reader.NamespaceURI); if (member != null) { SetMemberValue(member, ob, GetValueFromXmlString(Reader.Value, member.TypeData, member.MappedType), isValueList); } else if (IsXmlnsAttribute(Reader.Name)) { // If the map has NamespaceDeclarations, // then store this xmlns to the given member. // If the instance doesn't exist, then create. if (map.NamespaceDeclarations != null) { XmlSerializerNamespaces nss = this.GetMemberValue(map.NamespaceDeclarations, ob, isValueList) as XmlSerializerNamespaces; if (nss == null) { nss = new XmlSerializerNamespaces(); SetMemberValue(map.NamespaceDeclarations, ob, nss, isValueList); } if (Reader.Prefix == "xmlns") { nss.Add(Reader.LocalName, Reader.Value); } else { nss.Add("", Reader.Value); } } } else if (anyAttrMember != null) { XmlAttribute attr = (XmlAttribute)Document.ReadNode(Reader); ParseWsdlArrayType(attr); AddListValue(anyAttrMember.TypeData, ref anyAttributeArray, anyAttributeIndex++, attr, true); } else { ProcessUnknownAttribute(ob); } } if (anyAttrMember != null) { anyAttributeArray = ShrinkArray((Array)anyAttributeArray, anyAttributeIndex, anyAttrMember.TypeData.Type.GetElementType(), true); SetMemberValue(anyAttrMember, ob, anyAttributeArray, isValueList); } if (!isValueList) { Reader.MoveToElement(); if (Reader.IsEmptyElement) { SetListMembersDefaults(map, ob, isValueList); return; } Reader.ReadStartElement(); } // Reads elements bool[] readFlag = new bool[(map.ElementMembers != null) ? map.ElementMembers.Count : 0]; bool hasAnyReturnMember = (isValueList && _format == SerializationFormat.Encoded && map.ReturnMember != null); Reader.MoveToContent(); int[] indexes = null; object[] flatLists = null; object[] flatListsChoices = null; Fixup fixup = null; int ind = 0; int maxInd; if (readByOrder) { if (map.ElementMembers != null) { maxInd = map.ElementMembers.Count; } else { maxInd = 0; } } else { maxInd = int.MaxValue; } if (map.FlatLists != null) { indexes = new int[map.FlatLists.Count]; flatLists = new object[map.FlatLists.Count]; foreach (XmlTypeMapMemberExpandable mem in map.FlatLists) { if (IsReadOnly(mem, mem.TypeData, ob, isValueList)) { flatLists[mem.FlatArrayIndex] = mem.GetValue(ob); } else if (mem.TypeData.Type.IsArray) { flatLists[mem.FlatArrayIndex] = InitializeList(mem.TypeData); } else { object list = mem.GetValue(ob); if (list == null) { list = InitializeList(mem.TypeData); SetMemberValue(mem, ob, list, isValueList); } flatLists[mem.FlatArrayIndex] = list; } if (mem.ChoiceMember != null) { if (flatListsChoices == null) { flatListsChoices = new object[map.FlatLists.Count]; } flatListsChoices[mem.FlatArrayIndex] = InitializeList(mem.ChoiceTypeData); } } } if (_format == SerializationFormat.Encoded && map.ElementMembers != null) { FixupCallbackInfo info = new FixupCallbackInfo(this, map, isValueList); fixup = new Fixup(ob, new XmlSerializationFixupCallback(info.FixupMembers), map.ElementMembers.Count); AddFixup(fixup); } while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && (ind < maxInd)) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { XmlTypeMapElementInfo info; if (readByOrder) { info = map.GetElement(ind++); } else if (hasAnyReturnMember) { info = (XmlTypeMapElementInfo)((XmlTypeMapMemberElement)map.ReturnMember).ElementInfo[0]; hasAnyReturnMember = false; } else { info = map.GetElement(Reader.LocalName, Reader.NamespaceURI); } if (info != null && !readFlag[info.Member.Index]) { if (info.Member.GetType() == typeof(XmlTypeMapMemberList)) { if (_format == SerializationFormat.Encoded && info.MultiReferenceType) { object list = ReadReferencingElement(out fixup.Ids[info.Member.Index]); if (fixup.Ids[info.Member.Index] == null) // Already read { if (IsReadOnly(info.Member, info.TypeData, ob, isValueList)) { throw CreateReadOnlyCollectionException(info.TypeData.FullTypeName); } else { SetMemberValue(info.Member, ob, list, isValueList); } } else if (!info.MappedType.TypeData.Type.IsArray) { if (IsReadOnly(info.Member, info.TypeData, ob, isValueList)) { list = GetMemberValue(info.Member, ob, isValueList); } else { list = CreateList(info.MappedType.TypeData.Type); SetMemberValue(info.Member, ob, list, isValueList); } AddFixup(new CollectionFixup(list, new XmlSerializationCollectionFixupCallback(FillList), fixup.Ids[info.Member.Index])); fixup.Ids[info.Member.Index] = null; // The member already has the value, no further fix needed. } } else { if (IsReadOnly(info.Member, info.TypeData, ob, isValueList)) { ReadListElement(info.MappedType, info.IsNullable, GetMemberValue(info.Member, ob, isValueList), false); } else if (info.MappedType.TypeData.Type.IsArray) { object list = ReadListElement(info.MappedType, info.IsNullable, null, true); if (list != null || info.IsNullable) { SetMemberValue(info.Member, ob, list, isValueList); } } else { // If the member already has a list, reuse that list. No need to create a new one. object list = GetMemberValue(info.Member, ob, isValueList); if (list == null) { list = CreateList(info.MappedType.TypeData.Type); SetMemberValue(info.Member, ob, list, isValueList); } ReadListElement(info.MappedType, info.IsNullable, list, true); } } readFlag[info.Member.Index] = true; } else if (info.Member.GetType() == typeof(XmlTypeMapMemberFlatList)) { XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member; AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadObjectElement(info), !IsReadOnly(info.Member, info.TypeData, ob, isValueList)); if (mem.ChoiceMember != null) { AddListValue(mem.ChoiceTypeData, ref flatListsChoices[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex] - 1, info.ChoiceValue, true); } } else if (info.Member.GetType() == typeof(XmlTypeMapMemberAnyElement)) { XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member; if (mem.TypeData.IsListType) { AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode(mem.TypeData.ListItemTypeData, false), true); } else { SetMemberValue(mem, ob, ReadXmlNode(mem.TypeData, false), isValueList); } } else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement)) { object val; readFlag[info.Member.Index] = true; if (_format == SerializationFormat.Encoded) { if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive) { val = ReadReferencingElement(out fixup.Ids[info.Member.Index]); } else { val = ReadReferencingElement(info.Member.TypeData.XmlType, System.Xml.Schema.XmlSchema.Namespace, out fixup.Ids[info.Member.Index]); } if (info.MultiReferenceType) { if (fixup.Ids[info.Member.Index] == null) // already read { SetMemberValue(info.Member, ob, val, isValueList); } } else if (val != null) { SetMemberValue(info.Member, ob, val, isValueList); } } else { SetMemberValue(info.Member, ob, ReadObjectElement(info), isValueList); if (info.ChoiceValue != null) { XmlTypeMapMemberElement imem = (XmlTypeMapMemberElement)info.Member; imem.SetChoice(ob, info.ChoiceValue); } } } else { throw new InvalidOperationException("Unknown member type"); } } else if (map.DefaultAnyElementMember != null) { XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember; if (mem.TypeData.IsListType) { AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode(mem.TypeData.ListItemTypeData, false), true); } else { SetMemberValue(mem, ob, ReadXmlNode(mem.TypeData, false), isValueList); } } else { ProcessUnknownElement(ob); } } else if ((Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA) && map.XmlTextCollector != null) { if (map.XmlTextCollector is XmlTypeMapMemberExpandable) { XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector; XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList; TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData; object val = (itype.Type == typeof(string)) ? (object)Reader.ReadString() : (object)ReadXmlNode(itype, false); AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, val, true); } else { XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement)map.XmlTextCollector; XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)mem.ElementInfo[0]; if (info.TypeData.Type == typeof(string)) { SetMemberValue(mem, ob, ReadString((string)GetMemberValue(mem, ob, isValueList)), isValueList); } else { SetMemberValue(mem, ob, GetValueFromXmlString(Reader.ReadString(), info.TypeData, info.MappedType), isValueList); } } } else { UnknownNode(ob); } Reader.MoveToContent(); } if (flatLists != null) { foreach (XmlTypeMapMemberExpandable mem in map.FlatLists) { Object list = flatLists[mem.FlatArrayIndex]; if (mem.TypeData.Type.IsArray) { list = ShrinkArray((Array)list, indexes[mem.FlatArrayIndex], mem.TypeData.Type.GetElementType(), true); } if (!IsReadOnly(mem, mem.TypeData, ob, isValueList) && mem.TypeData.Type.IsArray) { SetMemberValue(mem, ob, list, isValueList); } } } if (flatListsChoices != null) { foreach (XmlTypeMapMemberExpandable mem in map.FlatLists) { Object list = flatListsChoices[mem.FlatArrayIndex]; if (list == null) { continue; } list = ShrinkArray((Array)list, indexes[mem.FlatArrayIndex], mem.ChoiceTypeData.Type.GetElementType(), true); XmlTypeMapMember.SetValue(ob, mem.ChoiceMember, list); } } SetListMembersDefaults(map, ob, isValueList); }
XmlTypeMapElementInfoList ImportAnyElementInfo(string defaultNamespace, XmlReflectionMember rmember, XmlTypeMapMemberElement member, XmlAttributes atts) { XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); ImportTextElementInfo(list, rmember.MemberType, member, atts); foreach (XmlAnyElementAttribute att in atts.XmlAnyElements) { XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(member, TypeTranslator.GetTypeData(typeof(XmlElement))); if (att.Name != null && att.Name != string.Empty) { elem.ElementName = att.Name; elem.Namespace = (att.Namespace != null) ? att.Namespace : ""; } else { elem.IsUnnamedAnyElement = true; elem.Namespace = defaultNamespace; if (att.Namespace != null) { throw new InvalidOperationException("The element " + rmember.MemberName + " has been attributed with an XmlAnyElementAttribute and a namespace '" + att.Namespace + "', but no name. When a namespace is supplied, a name is also required. Supply a name or remove the namespace."); } } list.Add(elem); } return(list); }
public void AddElementMemberAttributes (XmlTypeMapMemberElement member, string defaultNamespace, CodeAttributeDeclarationCollection attributes, bool forceUseMemberName) { TypeData defaultType = member.TypeData; bool addAlwaysAttr = false; if (member is XmlTypeMapMemberFlatList) { defaultType = defaultType.ListItemTypeData; addAlwaysAttr = true; } foreach (XmlTypeMapElementInfo einfo in member.ElementInfo) { if (ExportExtraElementAttributes (attributes, einfo, defaultNamespace, defaultType)) continue; GenerateElementInfoMember (attributes, member, einfo, defaultType, defaultNamespace, addAlwaysAttr, forceUseMemberName); if (einfo.MappedType != null) { ExportMapCode (einfo.MappedType); RemoveInclude (einfo.MappedType); } } GenerateElementMember (attributes, member); }
void ImportTextElementInfo (XmlTypeMapElementInfoList list, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts, string defaultNamespace) { if (atts.XmlText != null) { member.IsXmlTextCollector = true; if (atts.XmlText.Type != null) { TypeData td = TypeTranslator.GetTypeData (defaultType); if ((td.SchemaType == SchemaTypes.Primitive || td.SchemaType == SchemaTypes.Enum) && atts.XmlText.Type != defaultType) { throw new InvalidOperationException ("The type for XmlText may not be specified for primitive types."); } defaultType = atts.XmlText.Type; } #if !MOONLIGHT if (defaultType == typeof(XmlNode)) defaultType = typeof(XmlText); // Nodes must be text nodes #endif XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(defaultType, atts.XmlText.DataType)); if (elem.TypeData.SchemaType != SchemaTypes.Primitive && elem.TypeData.SchemaType != SchemaTypes.Enum && elem.TypeData.SchemaType != SchemaTypes.XmlNode && !(elem.TypeData.SchemaType == SchemaTypes.Array && elem.TypeData.ListItemTypeData.SchemaType == SchemaTypes.XmlNode) ) throw new InvalidOperationException ("XmlText cannot be used to encode complex types"); if (elem.TypeData.IsComplexType) elem.MappedType = ImportTypeMapping (defaultType, null, defaultNamespace); elem.IsTextElement = true; elem.WrappedElement = false; list.Add (elem); } }
XmlTypeMapElementInfoList ImportElementInfo (string defaultName, string defaultNamespace, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts) { XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); ImportTextElementInfo (list, defaultType, member, atts); if (atts.XmlElements.Count == 0 && list.Count == 0) { XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(defaultType)); elem.ElementName = defaultName; elem.Namespace = defaultNamespace; if (elem.TypeData.IsComplexType) elem.MappedType = ImportTypeMapping (defaultType, null, defaultNamespace); list.Add (elem); } bool multiType = (atts.XmlElements.Count > 1); foreach (XmlElementAttribute att in atts.XmlElements) { Type elemType = (att.Type != null) ? att.Type : defaultType; XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(elemType, att.DataType)); elem.ElementName = (att.ElementName != null) ? att.ElementName : defaultName; elem.Namespace = (att.Namespace != null) ? att.Namespace : defaultNamespace; elem.Form = att.Form; elem.IsNullable = att.IsNullable; if (elem.IsNullable && elem.TypeData.IsValueType) throw new InvalidOperationException ("IsNullable may not be 'true' for value type " + elem.TypeData.FullTypeName + " in member '" + defaultName + "'"); if (elem.TypeData.IsComplexType) { if (att.DataType != null) throw new InvalidOperationException ("'" + att.DataType + "' is an invalid value for the XmlElementAttribute.DateTime property. The property may only be specified for primitive types."); elem.MappedType = ImportTypeMapping (elemType, null, elem.Namespace); } if (att.ElementName != null) elem.ElementName = att.ElementName; else if (multiType) { if (elem.MappedType != null) elem.ElementName = elem.MappedType.ElementName; else elem.ElementName = TypeTranslator.GetTypeData(elemType).XmlType; } else elem.ElementName = defaultName; list.Add (elem); } return list; }
void AddElementFieldMember (CodeTypeDeclaration codeClass, XmlTypeMapMemberElement member, string defaultNamespace) { CodeMemberField codeField = CreateFieldMember (member); codeClass.Members.Add (codeField); CodeAttributeDeclarationCollection attributes = codeField.CustomAttributes; if (attributes == null) attributes = new CodeAttributeDeclarationCollection (); AddElementMemberAttributes (member, defaultNamespace, attributes, false); if (attributes.Count > 0) codeField.CustomAttributes = attributes; if (member.TypeData.IsValueType && member.IsOptionalValueType) { codeField = new CodeMemberField (typeof(bool), member.Name + "Specified"); codeField.Attributes = MemberAttributes.Public; codeClass.Members.Add (codeField); GenerateSpecifierMember (codeField); } }
XmlTypeMapElementInfoList ImportAnyElementInfo (string defaultNamespace, XmlReflectionMember rmember, XmlTypeMapMemberElement member, XmlAttributes atts) { XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); ImportTextElementInfo (list, rmember.MemberType, member, atts); foreach (XmlAnyElementAttribute att in atts.XmlAnyElements) { XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(typeof(XmlElement))); if (att.Name != null && att.Name != string.Empty) { elem.ElementName = att.Name; elem.Namespace = (att.Namespace != null) ? att.Namespace : ""; } else { elem.IsUnnamedAnyElement = true; elem.Namespace = defaultNamespace; if (att.Namespace != null) throw new InvalidOperationException ("The element " + rmember.MemberName + " has been attributed with an XmlAnyElementAttribute and a namespace '" + att.Namespace + "', but no name. When a namespace is supplied, a name is also required. Supply a name or remove the namespace."); } list.Add (elem); } return list; }
private XmlTypeMapMember CreateMapMember(XmlReflectionMember rmember, string defaultNamespace) { XmlTypeMapMember mapMember; SoapAttributes atts = rmember.SoapAttributes; TypeData typeData = TypeTranslator.GetTypeData(rmember.MemberType); if (atts.SoapAttribute != null) { // An attribute if (typeData.SchemaType != SchemaTypes.Enum && typeData.SchemaType != SchemaTypes.Primitive) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot serialize member '{0}' of type {1}. " + "SoapAttribute cannot be used to encode complex types.", rmember.MemberName, typeData.FullTypeName)); } if (atts.SoapElement != null) { throw new Exception("SoapAttributeAttribute and SoapElementAttribute cannot be applied to the same member"); } XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute(); if (atts.SoapAttribute.AttributeName.Length == 0) { mapAttribute.AttributeName = XmlConvert.EncodeLocalName(rmember.MemberName); } else { mapAttribute.AttributeName = XmlConvert.EncodeLocalName(atts.SoapAttribute.AttributeName); } mapAttribute.Namespace = (atts.SoapAttribute.Namespace != null) ? atts.SoapAttribute.Namespace : ""; if (typeData.IsComplexType) { mapAttribute.MappedType = ImportTypeMapping(typeData.Type, defaultNamespace); } typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.SoapAttribute.DataType); mapMember = mapAttribute; mapMember.DefaultValue = GetDefaultValue(typeData, atts.SoapDefaultValue); } else { if (typeData.SchemaType == SchemaTypes.Array) { mapMember = new XmlTypeMapMemberList(); } else { mapMember = new XmlTypeMapMemberElement(); } if (atts.SoapElement != null && atts.SoapElement.DataType.Length != 0) { typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.SoapElement.DataType); } // Creates an ElementInfo that identifies the element XmlTypeMapElementInfoList infoList = new XmlTypeMapElementInfoList(); XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(mapMember, typeData); elem.ElementName = XmlConvert.EncodeLocalName((atts.SoapElement != null && atts.SoapElement.ElementName.Length != 0) ? atts.SoapElement.ElementName : rmember.MemberName); elem.Namespace = string.Empty; elem.IsNullable = (atts.SoapElement != null) ? atts.SoapElement.IsNullable : false; if (typeData.IsComplexType) { elem.MappedType = ImportTypeMapping(typeData.Type, defaultNamespace); } infoList.Add(elem); ((XmlTypeMapMemberElement)mapMember).ElementInfo = infoList; } mapMember.TypeData = typeData; mapMember.Name = rmember.MemberName; mapMember.IsReturnValue = rmember.IsReturnValue; return(mapMember); }
/// <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(); }
private void ExportMembersMapSchema(XmlSchema schema, ClassMap map, XmlTypeMapping baseMap, XmlSchemaObjectCollection outAttributes, out XmlSchemaSequence particle, out XmlSchemaAnyAttribute anyAttribute) { particle = null; XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence(); ICollection elementMembers = map.ElementMembers; if (elementMembers != null && !map.HasSimpleContent) { foreach (object obj in elementMembers) { XmlTypeMapMemberElement xmlTypeMapMemberElement = (XmlTypeMapMemberElement)obj; if (baseMap == null || !this.DefinedInBaseMap(baseMap, xmlTypeMapMemberElement)) { Type type = xmlTypeMapMemberElement.GetType(); if (type == typeof(XmlTypeMapMemberFlatList)) { XmlSchemaParticle schemaArrayElement = this.GetSchemaArrayElement(schema, xmlTypeMapMemberElement.ElementInfo); if (schemaArrayElement != null) { xmlSchemaSequence.Items.Add(schemaArrayElement); } } else if (type == typeof(XmlTypeMapMemberAnyElement)) { xmlSchemaSequence.Items.Add(this.GetSchemaArrayElement(schema, xmlTypeMapMemberElement.ElementInfo)); } else if (type == typeof(XmlTypeMapMemberElement)) { this.GetSchemaElement(schema, (XmlTypeMapElementInfo)xmlTypeMapMemberElement.ElementInfo[0], xmlTypeMapMemberElement.DefaultValue, true, new XmlSchemaExporter.XmlSchemaObjectContainer(xmlSchemaSequence)); } else { this.GetSchemaElement(schema, (XmlTypeMapElementInfo)xmlTypeMapMemberElement.ElementInfo[0], true, new XmlSchemaExporter.XmlSchemaObjectContainer(xmlSchemaSequence)); } } } } if (xmlSchemaSequence.Items.Count > 0) { particle = xmlSchemaSequence; } ICollection attributeMembers = map.AttributeMembers; if (attributeMembers != null) { foreach (object obj2 in attributeMembers) { XmlTypeMapMemberAttribute xmlTypeMapMemberAttribute = (XmlTypeMapMemberAttribute)obj2; if (baseMap == null || !this.DefinedInBaseMap(baseMap, xmlTypeMapMemberAttribute)) { outAttributes.Add(this.GetSchemaAttribute(schema, xmlTypeMapMemberAttribute, true)); } } } XmlTypeMapMember defaultAnyAttributeMember = map.DefaultAnyAttributeMember; if (defaultAnyAttributeMember != null) { anyAttribute = new XmlSchemaAnyAttribute(); } else { anyAttribute = null; } }
void AddAnyElementFieldMember (CodeTypeDeclaration codeClass, XmlTypeMapMemberElement member, string defaultNamespace) { CodeMemberField codeField = CreateFieldMember (member); codeClass.Members.Add (codeField); CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection (); foreach (XmlTypeMapElementInfo einfo in member.ElementInfo) ExportExtraElementAttributes (attributes, einfo, defaultNamespace, einfo.TypeData); if (attributes.Count > 0) codeField.CustomAttributes = attributes; }
void ImportSequenceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaObjectCollection items, CodeIdentifiers classIds, bool multiValue, ref bool isMixed) { foreach (XmlSchemaObject item in items) { if (item is XmlSchemaElement) { string ns; XmlSchemaElement elem = (XmlSchemaElement) item; XmlTypeMapping emap; TypeData typeData = GetElementTypeData (typeQName, elem, null, out emap); XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns); if (elem.MaxOccurs == 1 && !multiValue) { XmlTypeMapMemberElement member = null; if (typeData.SchemaType != SchemaTypes.Array) { member = new XmlTypeMapMemberElement (); if (refElem.DefaultValue != null) member.DefaultValue = ImportDefaultValue (typeData, refElem.DefaultValue); } else if (GetTypeMapping (typeData).IsSimpleType) { // It is a simple list (space separated list). // Since this is not supported, map as a single item value member = new XmlTypeMapMemberElement (); #if NET_2_0 // In MS.NET those types are mapped to a string typeData = TypeTranslator.GetTypeData(typeof(string)); #else typeData = typeData.ListItemTypeData; #endif } else member = new XmlTypeMapMemberList (); if (elem.MinOccurs == 0 && typeData.IsValueType) member.IsOptionalValueType = true; member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member); member.Documentation = GetDocumentation (elem); member.TypeData = typeData; member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, items.IndexOf (item))); cmap.AddMember (member); } else { XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList (); member.ListMap = new ListMap (); member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member); member.Documentation = GetDocumentation (elem); member.TypeData = typeData.ListTypeData; member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, items.IndexOf (item))); member.ListMap.ItemInfo = member.ElementInfo; cmap.AddMember (member); } } else if (item is XmlSchemaAny) { XmlSchemaAny elem = (XmlSchemaAny) item; XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement (); member.Name = classIds.AddUnique ("Any", member); member.Documentation = GetDocumentation (elem); Type ctype; if (elem.MaxOccurs != 1 || multiValue) ctype = isMixed ? typeof(XmlNode[]) : typeof(XmlElement[]); else ctype = isMixed ? typeof(XmlNode) : typeof(XmlElement); member.TypeData = TypeTranslator.GetTypeData (ctype); XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, member.TypeData); einfo.IsUnnamedAnyElement = true; member.ElementInfo.Add (einfo); if (isMixed) { einfo = CreateTextElementInfo (typeQName.Namespace, member, member.TypeData); member.ElementInfo.Add (einfo); member.IsXmlTextCollector = true; isMixed = false; //Allow only one XmlTextAttribute } cmap.AddMember (member); } else if (item is XmlSchemaParticle) { ImportParticleContent (typeQName, cmap, (XmlSchemaParticle)item, classIds, multiValue, ref isMixed); } } }
public void AddArrayAttributes (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName) { GenerateArrayElement (attributes, member, defaultNamespace, forceUseMemberName); }
XmlTypeMapElementInfoList ImportElementInfo (Type cls, string defaultName, string defaultNamespace, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts) { EnumMap choiceEnumMap = null; Type choiceEnumType = null; XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); ImportTextElementInfo (list, defaultType, member, atts, defaultNamespace); if (atts.XmlChoiceIdentifier != null) { if (cls == null) throw new InvalidOperationException ("XmlChoiceIdentifierAttribute not supported in this context."); member.ChoiceMember = atts.XmlChoiceIdentifier.MemberName; MemberInfo[] mems = cls.GetMember (member.ChoiceMember, BindingFlags.Instance|BindingFlags.Public); if (mems.Length == 0) throw new InvalidOperationException ("Choice member '" + member.ChoiceMember + "' not found in class '" + cls); if (mems[0] is PropertyInfo) { PropertyInfo pi = (PropertyInfo)mems[0]; if (!pi.CanWrite || !pi.CanRead) throw new InvalidOperationException ("Choice property '" + member.ChoiceMember + "' must be read/write."); choiceEnumType = pi.PropertyType; } else choiceEnumType = ((FieldInfo)mems[0]).FieldType; member.ChoiceTypeData = TypeTranslator.GetTypeData (choiceEnumType); if (choiceEnumType.IsArray) choiceEnumType = choiceEnumType.GetElementType (); choiceEnumMap = ImportTypeMapping (choiceEnumType).ObjectMap as EnumMap; if (choiceEnumMap == null) throw new InvalidOperationException ("The member '" + mems[0].Name + "' is not a valid target for XmlChoiceIdentifierAttribute."); } if (atts.XmlElements.Count == 0 && list.Count == 0) { XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(defaultType)); elem.ElementName = defaultName; elem.Namespace = defaultNamespace; if (elem.TypeData.IsComplexType) elem.MappedType = ImportTypeMapping (defaultType, null, defaultNamespace); list.Add (elem); } bool multiType = (atts.XmlElements.Count > 1); foreach (XmlElementAttribute att in atts.XmlElements) { Type elemType = (att.Type != null) ? att.Type : defaultType; XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(elemType, att.DataType)); elem.Form = att.Form; if (elem.Form != XmlSchemaForm.Unqualified) elem.Namespace = (att.Namespace != null) ? att.Namespace : defaultNamespace; elem.IsNullable = att.IsNullable; if (elem.IsNullable && !elem.TypeData.IsNullable) throw new InvalidOperationException ("IsNullable may not be 'true' for value type " + elem.TypeData.FullTypeName + " in member '" + defaultName + "'"); if (elem.TypeData.IsComplexType) { if (att.DataType.Length != 0) throw new InvalidOperationException ( string.Format(CultureInfo.InvariantCulture, "'{0}' is " + "an invalid value for '{1}.{2}' of type '{3}'. " + "The property may only be specified for primitive types.", att.DataType, cls.FullName, defaultName, elem.TypeData.FullTypeName)); elem.MappedType = ImportTypeMapping (elemType, null, elem.Namespace); } if (att.ElementName.Length != 0) { elem.ElementName = XmlConvert.EncodeLocalName(att.ElementName); } else if (multiType) { if (elem.MappedType != null) { elem.ElementName = elem.MappedType.ElementName; } else { elem.ElementName = TypeTranslator.GetTypeData (elemType).XmlType; } } else { elem.ElementName = defaultName; } if (choiceEnumMap != null) { string cname = choiceEnumMap.GetEnumName (choiceEnumType.FullName, elem.ElementName); if (cname == null) throw new InvalidOperationException (string.Format ( CultureInfo.InvariantCulture, "Type {0} is missing" + " enumeration value '{1}' for element '{1} from" + " namespace '{2}'.", choiceEnumType, elem.ElementName, elem.Namespace)); elem.ChoiceValue = Enum.Parse (choiceEnumType, cname, false); } list.Add (elem); } return list; }
protected virtual void GenerateElementInfoMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName) { }
void ReadMembers(ClassMap map, object ob, bool isValueList, bool readBySoapOrder) { // Reads attributes ReadAttributeMembers(map, ob, isValueList); if (!isValueList) { Reader.MoveToElement(); if (Reader.IsEmptyElement) { SetListMembersDefaults(map, ob, isValueList); return; } Reader.ReadStartElement(); } // Reads elements bool[] readFlag = new bool[(map.ElementMembers != null) ? map.ElementMembers.Count : 0]; bool hasAnyReturnMember = (isValueList && _format == SerializationFormat.Encoded && map.ReturnMember != null); Reader.MoveToContent(); int[] indexes = null; object[] flatLists = null; object[] flatListsChoices = null; Fixup fixup = null; int ind = -1; int maxInd; if (readBySoapOrder) { if (map.ElementMembers != null) { maxInd = map.ElementMembers.Count; } else { maxInd = -1; } } else { maxInd = int.MaxValue; } if (map.FlatLists != null) { indexes = new int[map.FlatLists.Count]; flatLists = new object[map.FlatLists.Count]; foreach (XmlTypeMapMemberExpandable mem in map.FlatLists) { if (IsReadOnly(mem, mem.TypeData, ob, isValueList)) { flatLists [mem.FlatArrayIndex] = mem.GetValue(ob); } else if (mem.TypeData.Type.IsArray) { flatLists [mem.FlatArrayIndex] = InitializeList(mem.TypeData); } else { object list = mem.GetValue(ob); if (list == null) { list = InitializeList(mem.TypeData); SetMemberValue(mem, ob, list, isValueList); } flatLists [mem.FlatArrayIndex] = list; } if (mem.ChoiceMember != null) { if (flatListsChoices == null) { flatListsChoices = new object [map.FlatLists.Count]; } flatListsChoices [mem.FlatArrayIndex] = InitializeList(mem.ChoiceTypeData); } } } if (_format == SerializationFormat.Encoded && map.ElementMembers != null) { FixupCallbackInfo info = new FixupCallbackInfo(this, map, isValueList); fixup = new Fixup(ob, new XmlSerializationFixupCallback(info.FixupMembers), map.ElementMembers.Count); AddFixup(fixup); } XmlTypeMapMember previousMember = null; while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && (ind < maxInd - 1)) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { XmlTypeMapElementInfo info; if (readBySoapOrder) { info = map.GetElement(Reader.LocalName, Reader.NamespaceURI, ind); } else if (hasAnyReturnMember) { info = (XmlTypeMapElementInfo)((XmlTypeMapMemberElement)map.ReturnMember).ElementInfo[0]; hasAnyReturnMember = false; } else { if (map.IsOrderDependentMap) { info = map.GetElement(Reader.LocalName, Reader.NamespaceURI, ind); } else { info = map.GetElement(Reader.LocalName, Reader.NamespaceURI); } } if (info != null && !readFlag[info.Member.Index]) { if (info.Member != previousMember) { ind = info.ExplicitOrder + 1; // If the member is a flat list don't increase the index, since the next element may // be another item of the list. This is a fix for Xamarin bug #9193. if (info.Member is XmlTypeMapMemberFlatList) { ind--; } previousMember = info.Member; } if (info.Member.GetType() == typeof(XmlTypeMapMemberList)) { if (_format == SerializationFormat.Encoded && info.MultiReferenceType) { object list = ReadReferencingElement(out fixup.Ids[info.Member.Index]); if (fixup.Ids[info.Member.Index] == null) // Already read { if (IsReadOnly(info.Member, info.TypeData, ob, isValueList)) { throw CreateReadOnlyCollectionException(info.TypeData.FullTypeName); } else { SetMemberValue(info.Member, ob, list, isValueList); } } else if (!info.MappedType.TypeData.Type.IsArray) { if (IsReadOnly(info.Member, info.TypeData, ob, isValueList)) { list = GetMemberValue(info.Member, ob, isValueList); } else { list = CreateList(info.MappedType.TypeData.Type); SetMemberValue(info.Member, ob, list, isValueList); } AddFixup(new CollectionFixup(list, new XmlSerializationCollectionFixupCallback(FillList), fixup.Ids[info.Member.Index])); fixup.Ids[info.Member.Index] = null; // The member already has the value, no further fix needed. } } else { if (IsReadOnly(info.Member, info.TypeData, ob, isValueList)) { ReadListElement(info.MappedType, info.IsNullable, GetMemberValue(info.Member, ob, isValueList), false); } else if (info.MappedType.TypeData.Type.IsArray) { object list = ReadListElement(info.MappedType, info.IsNullable, null, true); if (list != null || info.IsNullable) { SetMemberValue(info.Member, ob, list, isValueList); } } else { // If the member already has a list, reuse that list. No need to create a new one. object list = GetMemberValue(info.Member, ob, isValueList); if (list == null) { list = CreateList(info.MappedType.TypeData.Type); SetMemberValue(info.Member, ob, list, isValueList); } ReadListElement(info.MappedType, info.IsNullable, list, true); } } readFlag[info.Member.Index] = true; } else if (info.Member.GetType() == typeof(XmlTypeMapMemberFlatList)) { XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member; AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadObjectElement(info), !IsReadOnly(info.Member, info.TypeData, ob, isValueList)); if (mem.ChoiceMember != null) { AddListValue(mem.ChoiceTypeData, ref flatListsChoices [mem.FlatArrayIndex], indexes[mem.FlatArrayIndex] - 1, info.ChoiceValue, true); } } else if (info.Member.GetType() == typeof(XmlTypeMapMemberAnyElement)) { XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member; if (mem.TypeData.IsListType) { AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode(mem.TypeData.ListItemTypeData, false), true); } else { SetMemberValue(mem, ob, ReadXmlNode(mem.TypeData, false), isValueList); } } else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement)) { object val; readFlag[info.Member.Index] = true; if (_format == SerializationFormat.Encoded) { if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive) { val = ReadReferencingElement(out fixup.Ids[info.Member.Index]); } else { val = ReadReferencingElement(info.Member.TypeData.XmlType, System.Xml.Schema.XmlSchema.Namespace, out fixup.Ids[info.Member.Index]); } if (info.MultiReferenceType) { if (fixup.Ids[info.Member.Index] == null) // already read { SetMemberValue(info.Member, ob, val, isValueList); } } else if (val != null) { SetMemberValue(info.Member, ob, val, isValueList); } } else { SetMemberValue(info.Member, ob, ReadObjectElement(info), isValueList); if (info.ChoiceValue != null) { XmlTypeMapMemberElement imem = (XmlTypeMapMemberElement)info.Member; imem.SetChoice(ob, info.ChoiceValue); } } } else { throw new InvalidOperationException("Unknown member type"); } } else if (map.DefaultAnyElementMember != null) { XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember; if (mem.TypeData.IsListType) { AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode(mem.TypeData.ListItemTypeData, false), true); } else { SetMemberValue(mem, ob, ReadXmlNode(mem.TypeData, false), isValueList); } } else { ProcessUnknownElement(ob); } } else if ((Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA) && map.XmlTextCollector != null) { if (map.XmlTextCollector is XmlTypeMapMemberExpandable) { XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector; XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList; TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData; object val = (itype.Type == typeof(string)) ? (object)Reader.ReadString() : (object)ReadXmlNode(itype, false); AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, val, true); } else { XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement)map.XmlTextCollector; XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)mem.ElementInfo [0]; if (info.TypeData.Type == typeof(string)) { SetMemberValue(mem, ob, ReadString((string)GetMemberValue(mem, ob, isValueList)), isValueList); } else { SetMemberValue(mem, ob, GetValueFromXmlString(Reader.ReadString(), info.TypeData, info.MappedType), isValueList); } } } else { UnknownNode(ob); } Reader.MoveToContent(); } if (flatLists != null) { foreach (XmlTypeMapMemberExpandable mem in map.FlatLists) { Object list = flatLists[mem.FlatArrayIndex]; if (mem.TypeData.Type.IsArray) { list = ShrinkArray((Array)list, indexes[mem.FlatArrayIndex], mem.TypeData.Type.GetElementType(), true); } if (!IsReadOnly(mem, mem.TypeData, ob, isValueList) && mem.TypeData.Type.IsArray) { SetMemberValue(mem, ob, list, isValueList); } } } if (flatListsChoices != null) { foreach (XmlTypeMapMemberExpandable mem in map.FlatLists) { Object list = flatListsChoices[mem.FlatArrayIndex]; if (list == null) { continue; } list = ShrinkArray((Array)list, indexes[mem.FlatArrayIndex], mem.ChoiceTypeData.Type.GetElementType(), true); XmlTypeMapMember.SetValue(ob, mem.ChoiceMember, list); } } SetListMembersDefaults(map, ob, isValueList); }
protected virtual void GenerateElementMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member) { }
private XmlTypeMapMember CreateMapMember (XmlReflectionMember rmember, string defaultNamespace) { XmlTypeMapMember mapMember; XmlAttributes atts = rmember.XmlAttributes; TypeData typeData = TypeTranslator.GetTypeData (rmember.MemberType); if (atts.XmlAnyAttribute != null) { if ( (rmember.MemberType.FullName == "System.Xml.XmlAttribute[]") || (rmember.MemberType.FullName == "System.Xml.XmlNode[]") ) { mapMember = new XmlTypeMapMemberAnyAttribute(); } else throw new InvalidOperationException ("XmlAnyAttributeAttribute can only be applied to members of type XmlAttribute[] or XmlNode[]"); } else if (atts.XmlAnyElements != null && atts.XmlAnyElements.Count > 0) { if ( (rmember.MemberType.FullName == "System.Xml.XmlElement[]") || (rmember.MemberType.FullName == "System.Xml.XmlNode[]") || (rmember.MemberType.FullName == "System.Xml.XmlElement")) { XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement(); member.ElementInfo = ImportAnyElementInfo (defaultNamespace, rmember, member, atts); mapMember = member; } else throw new InvalidOperationException ("XmlAnyElementAttribute can only be applied to members of type XmlElement, XmlElement[] or XmlNode[]"); } else if (atts.Xmlns) { XmlTypeMapMemberNamespaces mapNamespaces = new XmlTypeMapMemberNamespaces (); mapMember = mapNamespaces; } else if (atts.XmlAttribute != null) { // An attribute if (atts.XmlElements != null && atts.XmlElements.Count > 0) throw new Exception ("XmlAttributeAttribute and XmlElementAttribute cannot be applied to the same member"); XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute (); if (atts.XmlAttribute.AttributeName == null) mapAttribute.AttributeName = rmember.MemberName; else mapAttribute.AttributeName = atts.XmlAttribute.AttributeName; if (typeData.IsComplexType) mapAttribute.MappedType = ImportTypeMapping (typeData.Type, null, mapAttribute.Namespace); if (atts.XmlAttribute.Namespace != null && atts.XmlAttribute.Namespace != defaultNamespace) { if (atts.XmlAttribute.Form == XmlSchemaForm.Unqualified) throw new InvalidOperationException ("The Form property may not be 'Unqualified' when an explicit Namespace property is present"); mapAttribute.Form = XmlSchemaForm.Qualified; mapAttribute.Namespace = atts.XmlAttribute.Namespace; } else { mapAttribute.Form = atts.XmlAttribute.Form; if (atts.XmlAttribute.Form == XmlSchemaForm.Qualified) mapAttribute.Namespace = defaultNamespace; else mapAttribute.Namespace = ""; } typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.XmlAttribute.DataType); mapMember = mapAttribute; } else if (typeData.SchemaType == SchemaTypes.Array) { // If the member has a single XmlElementAttribute and the type is the type of the member, // then it is not a flat list if (atts.XmlElements.Count > 1 || (atts.XmlElements.Count == 1 && atts.XmlElements[0].Type != typeData.Type) || (atts.XmlText != null)) { // A flat list // TODO: check that it does not have XmlArrayAttribute XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList (); member.ListMap = new ListMap (); member.ListMap.ItemInfo = ImportElementInfo (rmember.MemberName, defaultNamespace, typeData.ListItemType, member, atts); member.ElementInfo = member.ListMap.ItemInfo; mapMember = member; } else { // A list XmlTypeMapMemberList member = new XmlTypeMapMemberList (); // Creates an ElementInfo that identifies the array instance. member.ElementInfo = new XmlTypeMapElementInfoList(); XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, typeData); elem.ElementName = (atts.XmlArray != null && atts.XmlArray.ElementName != null) ? atts.XmlArray.ElementName : rmember.MemberName; elem.Namespace = (atts.XmlArray != null && atts.XmlArray.Namespace != null) ? atts.XmlArray.Namespace : defaultNamespace; elem.MappedType = ImportListMapping (rmember.MemberType, null, elem.Namespace, atts, 0); elem.IsNullable = (atts.XmlArray != null) ? atts.XmlArray.IsNullable : false; elem.Form = (atts.XmlArray != null) ? atts.XmlArray.Form : XmlSchemaForm.Qualified; member.ElementInfo.Add (elem); mapMember = member; } } else { // An element XmlTypeMapMemberElement member = new XmlTypeMapMemberElement (); member.ElementInfo = ImportElementInfo (rmember.MemberName, defaultNamespace, rmember.MemberType, member, atts); mapMember = member; } mapMember.DefaultValue = atts.XmlDefaultValue; mapMember.TypeData = typeData; mapMember.Name = rmember.MemberName; mapMember.IsReturnValue = rmember.IsReturnValue; return mapMember; }
public void AddArrayAttributes(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName) { GenerateArrayElement(attributes, member, defaultNamespace, forceUseMemberName); }
XmlTypeMapElementInfoList ImportElementInfo(string defaultName, string defaultNamespace, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts) { XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); ImportTextElementInfo(list, defaultType, member, atts); if (atts.XmlElements.Count == 0 && list.Count == 0) { XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(member, TypeTranslator.GetTypeData(defaultType)); elem.ElementName = defaultName; elem.Namespace = defaultNamespace; if (elem.TypeData.IsComplexType) { elem.MappedType = ImportTypeMapping(defaultType, null, defaultNamespace); } list.Add(elem); } bool multiType = (atts.XmlElements.Count > 1); foreach (XmlElementAttribute att in atts.XmlElements) { Type elemType = (att.Type != null) ? att.Type : defaultType; XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(member, TypeTranslator.GetTypeData(elemType, att.DataType)); elem.ElementName = (att.ElementName != null) ? att.ElementName : defaultName; elem.Namespace = (att.Namespace != null) ? att.Namespace : defaultNamespace; elem.Form = att.Form; elem.IsNullable = att.IsNullable; if (elem.IsNullable && elem.TypeData.IsValueType) { throw new InvalidOperationException("IsNullable may not be 'true' for value type " + elem.TypeData.FullTypeName + " in member '" + defaultName + "'"); } if (elem.TypeData.IsComplexType) { if (att.DataType != null) { throw new InvalidOperationException("'" + att.DataType + "' is an invalid value for the XmlElementAttribute.DateTime property. The property may only be specified for primitive types."); } elem.MappedType = ImportTypeMapping(elemType, null, elem.Namespace); } if (att.ElementName != null) { elem.ElementName = att.ElementName; } else if (multiType) { if (elem.MappedType != null) { elem.ElementName = elem.MappedType.ElementName; } else { elem.ElementName = TypeTranslator.GetTypeData(elemType).XmlType; } } else { elem.ElementName = defaultName; } list.Add(elem); } return(list); }
protected virtual void GenerateElementMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member) { }
protected override void GenerateElementMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member) { if (member.ChoiceMember != null) { CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlChoiceIdentifier"); att.Arguments.Add (GetArg(member.ChoiceMember)); attributes.Add (att); } if (member.Ignore) attributes.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlIgnoreAttribute")); }
protected override void GenerateElementInfoMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName) { CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Xml.Serialization.SoapElement"); if (forceUseMemberName || einfo.ElementName != member.Name) { att.Arguments.Add(GetArg(einfo.ElementName)); } // if (einfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", true)); MS seems to ignore this if (!TypeTranslator.IsDefaultPrimitiveTpeData(einfo.TypeData)) { att.Arguments.Add(GetArg("DataType", einfo.TypeData.XmlType)); } if (addAlwaysAttr || att.Arguments.Count > 0) { attributes.Add(att); } }
private XmlTypeMapMember CreateMapMember (XmlReflectionMember rmember, string defaultNamespace) { XmlTypeMapMember mapMember; SoapAttributes atts = rmember.SoapAttributes; TypeData typeData = TypeTranslator.GetTypeData (rmember.MemberType); if (atts.SoapAttribute != null) { // An attribute if (typeData.SchemaType != SchemaTypes.Enum && typeData.SchemaType != SchemaTypes.Primitive) { throw new InvalidOperationException (string.Format (CultureInfo.InvariantCulture, "Cannot serialize member '{0}' of type {1}. " + "SoapAttribute cannot be used to encode complex types.", rmember.MemberName, typeData.FullTypeName)); } if (atts.SoapElement != null) throw new Exception ("SoapAttributeAttribute and SoapElementAttribute cannot be applied to the same member"); XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute (); if (atts.SoapAttribute.AttributeName.Length == 0) mapAttribute.AttributeName = XmlConvert.EncodeLocalName (rmember.MemberName); else mapAttribute.AttributeName = XmlConvert.EncodeLocalName (atts.SoapAttribute.AttributeName); mapAttribute.Namespace = (atts.SoapAttribute.Namespace != null) ? atts.SoapAttribute.Namespace : ""; if (typeData.IsComplexType) mapAttribute.MappedType = ImportTypeMapping (typeData.Type, defaultNamespace); typeData = TypeTranslator.GetTypeData (rmember.MemberType, atts.SoapAttribute.DataType); mapMember = mapAttribute; mapMember.DefaultValue = GetDefaultValue (typeData, atts.SoapDefaultValue); } else { if (typeData.SchemaType == SchemaTypes.Array) mapMember = new XmlTypeMapMemberList (); else mapMember = new XmlTypeMapMemberElement (); if (atts.SoapElement != null && atts.SoapElement.DataType.Length != 0) typeData = TypeTranslator.GetTypeData (rmember.MemberType, atts.SoapElement.DataType); // Creates an ElementInfo that identifies the element XmlTypeMapElementInfoList infoList = new XmlTypeMapElementInfoList(); XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (mapMember, typeData); elem.ElementName = XmlConvert.EncodeLocalName ((atts.SoapElement != null && atts.SoapElement.ElementName.Length != 0) ? atts.SoapElement.ElementName : rmember.MemberName); elem.Namespace = string.Empty; elem.IsNullable = (atts.SoapElement != null) ? atts.SoapElement.IsNullable : false; if (typeData.IsComplexType) elem.MappedType = ImportTypeMapping (typeData.Type, defaultNamespace); infoList.Add (elem); ((XmlTypeMapMemberElement)mapMember).ElementInfo = infoList; } mapMember.TypeData = typeData; mapMember.Name = rmember.MemberName; mapMember.IsReturnValue = rmember.IsReturnValue; return mapMember; }
void ImportSimpleContent (XmlQualifiedName typeQName, XmlTypeMapping map, XmlSchemaSimpleContent content, CodeIdentifiers classIds, bool isMixed) { XmlSchemaSimpleContentExtension ext = content.Content as XmlSchemaSimpleContentExtension; ClassMap cmap = (ClassMap)map.ObjectMap; XmlQualifiedName qname = GetContentBaseType (content.Content); TypeData simpleType = null; if (!IsPrimitiveTypeNamespace (qname.Namespace)) { // Add base map members to this map XmlTypeMapping baseMap = ImportType (qname, null, true); BuildPendingMap (baseMap); if (baseMap.IsSimpleType) { simpleType = baseMap.TypeData; } else { ClassMap baseClassMap = (ClassMap)baseMap.ObjectMap; foreach (XmlTypeMapMember member in baseClassMap.AllMembers) cmap.AddMember (member); map.BaseMap = baseMap; baseMap.DerivedTypes.Add (map); } } else simpleType = FindBuiltInType (qname); if (simpleType != null) { XmlTypeMapMemberElement member = new XmlTypeMapMemberElement (); member.Name = classIds.AddUnique("Value", member); member.TypeData = simpleType; member.ElementInfo.Add (CreateTextElementInfo (typeQName.Namespace, member, member.TypeData)); member.IsXmlTextCollector = true; cmap.AddMember (member); } if (ext != null) ImportAttributes (typeQName, cmap, ext.Attributes, ext.AnyAttribute, classIds); }
protected virtual void GenerateArrayElement (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName) { }
void ImportTextElementInfo (XmlTypeMapElementInfoList list, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts) { if (atts.XmlText != null) { member.IsXmlTextCollector = true; if (atts.XmlText.Type != null) defaultType = atts.XmlText.Type; if (defaultType == typeof(XmlNode)) defaultType = typeof(XmlText); // Nodes must be text nodes XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(defaultType, atts.XmlText.DataType)); if (elem.TypeData.SchemaType != SchemaTypes.Primitive && elem.TypeData.SchemaType != SchemaTypes.Enum && elem.TypeData.SchemaType != SchemaTypes.XmlNode && !(elem.TypeData.SchemaType == SchemaTypes.Array && elem.TypeData.ListItemTypeData.SchemaType == SchemaTypes.XmlNode) ) throw new InvalidOperationException ("XmlText cannot be used to encode complex types"); elem.IsTextElement = true; elem.WrappedElement = false; list.Add (elem); } }
protected virtual void GenerateElementInfoMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName) { }
private XmlTypeMapMember CreateMapMember (XmlReflectionMember rmember, string defaultNamespace) { XmlTypeMapMember mapMember; SoapAttributes atts = rmember.SoapAttributes; TypeData typeData = TypeTranslator.GetTypeData (rmember.MemberType); if (atts.SoapAttribute != null) { // An attribute if (atts.SoapElement != null) throw new Exception ("SoapAttributeAttribute and SoapElementAttribute cannot be applied to the same member"); XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute (); if (atts.SoapAttribute.AttributeName == null) mapAttribute.AttributeName = rmember.MemberName; else mapAttribute.AttributeName = atts.SoapAttribute.AttributeName; mapAttribute.Namespace = (atts.SoapAttribute.Namespace != null) ? atts.SoapAttribute.Namespace : ""; if (typeData.IsComplexType) mapAttribute.MappedType = ImportTypeMapping (typeData.Type, defaultNamespace); typeData = TypeTranslator.GetTypeData (rmember.MemberType, atts.SoapAttribute.DataType); mapMember = mapAttribute; } else { if (typeData.SchemaType == SchemaTypes.Array) mapMember = new XmlTypeMapMemberList (); else mapMember = new XmlTypeMapMemberElement (); if (atts.SoapElement != null && atts.SoapElement.DataType != null) typeData = TypeTranslator.GetTypeData (rmember.MemberType, atts.SoapElement.DataType); // Creates an ElementInfo that identifies the element XmlTypeMapElementInfoList infoList = new XmlTypeMapElementInfoList(); XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (mapMember, typeData); elem.ElementName = (atts.SoapElement != null && atts.SoapElement.ElementName != null) ? atts.SoapElement.ElementName : rmember.MemberName; elem.Namespace = string.Empty; elem.IsNullable = (atts.SoapElement != null) ? atts.SoapElement.IsNullable : false; if (typeData.IsComplexType) elem.MappedType = ImportTypeMapping (typeData.Type, defaultNamespace); infoList.Add (elem); ((XmlTypeMapMemberElement)mapMember).ElementInfo = infoList; } mapMember.TypeData = typeData; mapMember.Name = rmember.MemberName; mapMember.IsReturnValue = rmember.IsReturnValue; return mapMember; }
protected virtual void GenerateArrayElement(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName) { }
private void ReadMembers(ClassMap map, object ob, bool isValueList, bool readByOrder) { this.ReadAttributeMembers(map, ob, isValueList); if (!isValueList) { base.Reader.MoveToElement(); if (base.Reader.IsEmptyElement) { this.SetListMembersDefaults(map, ob, isValueList); return; } base.Reader.ReadStartElement(); } bool[] array = new bool[(map.ElementMembers == null) ? 0 : map.ElementMembers.Count]; bool flag = isValueList && this._format == SerializationFormat.Encoded && map.ReturnMember != null; base.Reader.MoveToContent(); int[] array2 = null; object[] array3 = null; object[] array4 = null; XmlSerializationReader.Fixup fixup = null; int num = 0; int num2; if (readByOrder) { if (map.ElementMembers != null) { num2 = map.ElementMembers.Count; } else { num2 = 0; } } else { num2 = int.MaxValue; } if (map.FlatLists != null) { array2 = new int[map.FlatLists.Count]; array3 = new object[map.FlatLists.Count]; foreach (object obj in map.FlatLists) { XmlTypeMapMemberExpandable xmlTypeMapMemberExpandable = (XmlTypeMapMemberExpandable)obj; if (this.IsReadOnly(xmlTypeMapMemberExpandable, xmlTypeMapMemberExpandable.TypeData, ob, isValueList)) { array3[xmlTypeMapMemberExpandable.FlatArrayIndex] = xmlTypeMapMemberExpandable.GetValue(ob); } else if (xmlTypeMapMemberExpandable.TypeData.Type.IsArray) { array3[xmlTypeMapMemberExpandable.FlatArrayIndex] = this.InitializeList(xmlTypeMapMemberExpandable.TypeData); } else { object obj2 = xmlTypeMapMemberExpandable.GetValue(ob); if (obj2 == null) { obj2 = this.InitializeList(xmlTypeMapMemberExpandable.TypeData); this.SetMemberValue(xmlTypeMapMemberExpandable, ob, obj2, isValueList); } array3[xmlTypeMapMemberExpandable.FlatArrayIndex] = obj2; } if (xmlTypeMapMemberExpandable.ChoiceMember != null) { if (array4 == null) { array4 = new object[map.FlatLists.Count]; } array4[xmlTypeMapMemberExpandable.FlatArrayIndex] = this.InitializeList(xmlTypeMapMemberExpandable.ChoiceTypeData); } } } if (this._format == SerializationFormat.Encoded && map.ElementMembers != null) { XmlSerializationReaderInterpreter.FixupCallbackInfo @object = new XmlSerializationReaderInterpreter.FixupCallbackInfo(this, map, isValueList); fixup = new XmlSerializationReader.Fixup(ob, new XmlSerializationFixupCallback(@object.FixupMembers), map.ElementMembers.Count); base.AddFixup(fixup); } while (base.Reader.NodeType != XmlNodeType.EndElement && num < num2) { if (base.Reader.NodeType == XmlNodeType.Element) { XmlTypeMapElementInfo xmlTypeMapElementInfo; if (readByOrder) { xmlTypeMapElementInfo = map.GetElement(num++); } else if (flag) { xmlTypeMapElementInfo = (XmlTypeMapElementInfo)((XmlTypeMapMemberElement)map.ReturnMember).ElementInfo[0]; flag = false; } else { xmlTypeMapElementInfo = map.GetElement(base.Reader.LocalName, base.Reader.NamespaceURI); } if (xmlTypeMapElementInfo != null && !array[xmlTypeMapElementInfo.Member.Index]) { if (xmlTypeMapElementInfo.Member.GetType() == typeof(XmlTypeMapMemberList)) { if (this._format == SerializationFormat.Encoded && xmlTypeMapElementInfo.MultiReferenceType) { object obj3 = base.ReadReferencingElement(out fixup.Ids[xmlTypeMapElementInfo.Member.Index]); if (fixup.Ids[xmlTypeMapElementInfo.Member.Index] == null) { if (this.IsReadOnly(xmlTypeMapElementInfo.Member, xmlTypeMapElementInfo.TypeData, ob, isValueList)) { throw base.CreateReadOnlyCollectionException(xmlTypeMapElementInfo.TypeData.FullTypeName); } this.SetMemberValue(xmlTypeMapElementInfo.Member, ob, obj3, isValueList); } else if (!xmlTypeMapElementInfo.MappedType.TypeData.Type.IsArray) { if (this.IsReadOnly(xmlTypeMapElementInfo.Member, xmlTypeMapElementInfo.TypeData, ob, isValueList)) { obj3 = this.GetMemberValue(xmlTypeMapElementInfo.Member, ob, isValueList); } else { obj3 = this.CreateList(xmlTypeMapElementInfo.MappedType.TypeData.Type); this.SetMemberValue(xmlTypeMapElementInfo.Member, ob, obj3, isValueList); } base.AddFixup(new XmlSerializationReader.CollectionFixup(obj3, new XmlSerializationCollectionFixupCallback(this.FillList), fixup.Ids[xmlTypeMapElementInfo.Member.Index])); fixup.Ids[xmlTypeMapElementInfo.Member.Index] = null; } } else if (this.IsReadOnly(xmlTypeMapElementInfo.Member, xmlTypeMapElementInfo.TypeData, ob, isValueList)) { this.ReadListElement(xmlTypeMapElementInfo.MappedType, xmlTypeMapElementInfo.IsNullable, this.GetMemberValue(xmlTypeMapElementInfo.Member, ob, isValueList), false); } else if (xmlTypeMapElementInfo.MappedType.TypeData.Type.IsArray) { object obj4 = this.ReadListElement(xmlTypeMapElementInfo.MappedType, xmlTypeMapElementInfo.IsNullable, null, true); if (obj4 != null || xmlTypeMapElementInfo.IsNullable) { this.SetMemberValue(xmlTypeMapElementInfo.Member, ob, obj4, isValueList); } } else { object obj5 = this.GetMemberValue(xmlTypeMapElementInfo.Member, ob, isValueList); if (obj5 == null) { obj5 = this.CreateList(xmlTypeMapElementInfo.MappedType.TypeData.Type); this.SetMemberValue(xmlTypeMapElementInfo.Member, ob, obj5, isValueList); } this.ReadListElement(xmlTypeMapElementInfo.MappedType, xmlTypeMapElementInfo.IsNullable, obj5, true); } array[xmlTypeMapElementInfo.Member.Index] = true; } else if (xmlTypeMapElementInfo.Member.GetType() == typeof(XmlTypeMapMemberFlatList)) { XmlTypeMapMemberFlatList xmlTypeMapMemberFlatList = (XmlTypeMapMemberFlatList)xmlTypeMapElementInfo.Member; this.AddListValue(xmlTypeMapMemberFlatList.TypeData, ref array3[xmlTypeMapMemberFlatList.FlatArrayIndex], array2[xmlTypeMapMemberFlatList.FlatArrayIndex]++, this.ReadObjectElement(xmlTypeMapElementInfo), !this.IsReadOnly(xmlTypeMapElementInfo.Member, xmlTypeMapElementInfo.TypeData, ob, isValueList)); if (xmlTypeMapMemberFlatList.ChoiceMember != null) { this.AddListValue(xmlTypeMapMemberFlatList.ChoiceTypeData, ref array4[xmlTypeMapMemberFlatList.FlatArrayIndex], array2[xmlTypeMapMemberFlatList.FlatArrayIndex] - 1, xmlTypeMapElementInfo.ChoiceValue, true); } } else if (xmlTypeMapElementInfo.Member.GetType() == typeof(XmlTypeMapMemberAnyElement)) { XmlTypeMapMemberAnyElement xmlTypeMapMemberAnyElement = (XmlTypeMapMemberAnyElement)xmlTypeMapElementInfo.Member; if (xmlTypeMapMemberAnyElement.TypeData.IsListType) { this.AddListValue(xmlTypeMapMemberAnyElement.TypeData, ref array3[xmlTypeMapMemberAnyElement.FlatArrayIndex], array2[xmlTypeMapMemberAnyElement.FlatArrayIndex]++, this.ReadXmlNode(xmlTypeMapMemberAnyElement.TypeData.ListItemTypeData, false), true); } else { this.SetMemberValue(xmlTypeMapMemberAnyElement, ob, this.ReadXmlNode(xmlTypeMapMemberAnyElement.TypeData, false), isValueList); } } else { if (xmlTypeMapElementInfo.Member.GetType() != typeof(XmlTypeMapMemberElement)) { throw new InvalidOperationException("Unknown member type"); } array[xmlTypeMapElementInfo.Member.Index] = true; if (this._format == SerializationFormat.Encoded) { object obj6; if (xmlTypeMapElementInfo.Member.TypeData.SchemaType != SchemaTypes.Primitive) { obj6 = base.ReadReferencingElement(out fixup.Ids[xmlTypeMapElementInfo.Member.Index]); } else { obj6 = base.ReadReferencingElement(xmlTypeMapElementInfo.Member.TypeData.XmlType, "http://www.w3.org/2001/XMLSchema", out fixup.Ids[xmlTypeMapElementInfo.Member.Index]); } if (xmlTypeMapElementInfo.MultiReferenceType) { if (fixup.Ids[xmlTypeMapElementInfo.Member.Index] == null) { this.SetMemberValue(xmlTypeMapElementInfo.Member, ob, obj6, isValueList); } } else if (obj6 != null) { this.SetMemberValue(xmlTypeMapElementInfo.Member, ob, obj6, isValueList); } } else { this.SetMemberValue(xmlTypeMapElementInfo.Member, ob, this.ReadObjectElement(xmlTypeMapElementInfo), isValueList); if (xmlTypeMapElementInfo.ChoiceValue != null) { XmlTypeMapMemberElement xmlTypeMapMemberElement = (XmlTypeMapMemberElement)xmlTypeMapElementInfo.Member; xmlTypeMapMemberElement.SetChoice(ob, xmlTypeMapElementInfo.ChoiceValue); } } } } else if (map.DefaultAnyElementMember != null) { XmlTypeMapMemberAnyElement defaultAnyElementMember = map.DefaultAnyElementMember; if (defaultAnyElementMember.TypeData.IsListType) { this.AddListValue(defaultAnyElementMember.TypeData, ref array3[defaultAnyElementMember.FlatArrayIndex], array2[defaultAnyElementMember.FlatArrayIndex]++, this.ReadXmlNode(defaultAnyElementMember.TypeData.ListItemTypeData, false), true); } else { this.SetMemberValue(defaultAnyElementMember, ob, this.ReadXmlNode(defaultAnyElementMember.TypeData, false), isValueList); } } else { this.ProcessUnknownElement(ob); } } else if ((base.Reader.NodeType == XmlNodeType.Text || base.Reader.NodeType == XmlNodeType.CDATA) && map.XmlTextCollector != null) { if (map.XmlTextCollector is XmlTypeMapMemberExpandable) { XmlTypeMapMemberExpandable xmlTypeMapMemberExpandable2 = (XmlTypeMapMemberExpandable)map.XmlTextCollector; XmlTypeMapMemberFlatList xmlTypeMapMemberFlatList2 = xmlTypeMapMemberExpandable2 as XmlTypeMapMemberFlatList; TypeData typeData = (xmlTypeMapMemberFlatList2 != null) ? xmlTypeMapMemberFlatList2.ListMap.FindTextElement().TypeData : xmlTypeMapMemberExpandable2.TypeData.ListItemTypeData; object value = (typeData.Type != typeof(string)) ? this.ReadXmlNode(typeData, false) : base.Reader.ReadString(); this.AddListValue(xmlTypeMapMemberExpandable2.TypeData, ref array3[xmlTypeMapMemberExpandable2.FlatArrayIndex], array2[xmlTypeMapMemberExpandable2.FlatArrayIndex]++, value, true); } else { XmlTypeMapMemberElement xmlTypeMapMemberElement2 = (XmlTypeMapMemberElement)map.XmlTextCollector; XmlTypeMapElementInfo xmlTypeMapElementInfo2 = (XmlTypeMapElementInfo)xmlTypeMapMemberElement2.ElementInfo[0]; if (xmlTypeMapElementInfo2.TypeData.Type == typeof(string)) { this.SetMemberValue(xmlTypeMapMemberElement2, ob, base.ReadString((string)this.GetMemberValue(xmlTypeMapMemberElement2, ob, isValueList)), isValueList); } else { this.SetMemberValue(xmlTypeMapMemberElement2, ob, this.GetValueFromXmlString(base.Reader.ReadString(), xmlTypeMapElementInfo2.TypeData, xmlTypeMapElementInfo2.MappedType), isValueList); } } } else { base.UnknownNode(ob); } base.Reader.MoveToContent(); } if (array3 != null) { foreach (object obj7 in map.FlatLists) { XmlTypeMapMemberExpandable xmlTypeMapMemberExpandable3 = (XmlTypeMapMemberExpandable)obj7; object obj8 = array3[xmlTypeMapMemberExpandable3.FlatArrayIndex]; if (xmlTypeMapMemberExpandable3.TypeData.Type.IsArray) { obj8 = base.ShrinkArray((Array)obj8, array2[xmlTypeMapMemberExpandable3.FlatArrayIndex], xmlTypeMapMemberExpandable3.TypeData.Type.GetElementType(), true); } if (!this.IsReadOnly(xmlTypeMapMemberExpandable3, xmlTypeMapMemberExpandable3.TypeData, ob, isValueList) && xmlTypeMapMemberExpandable3.TypeData.Type.IsArray) { this.SetMemberValue(xmlTypeMapMemberExpandable3, ob, obj8, isValueList); } } } if (array4 != null) { foreach (object obj9 in map.FlatLists) { XmlTypeMapMemberExpandable xmlTypeMapMemberExpandable4 = (XmlTypeMapMemberExpandable)obj9; object obj10 = array4[xmlTypeMapMemberExpandable4.FlatArrayIndex]; if (obj10 != null) { obj10 = base.ShrinkArray((Array)obj10, array2[xmlTypeMapMemberExpandable4.FlatArrayIndex], xmlTypeMapMemberExpandable4.ChoiceTypeData.Type.GetElementType(), true); XmlTypeMapMember.SetValue(ob, xmlTypeMapMemberExpandable4.ChoiceMember, obj10); } } } this.SetListMembersDefaults(map, ob, isValueList); }
void ImportChoiceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaChoice choice, CodeIdentifiers classIds, bool multiValue) { XmlTypeMapElementInfoList choices = new XmlTypeMapElementInfoList (); multiValue = ImportChoices (typeQName, null, choices, choice.Items) || multiValue; if (choices.Count == 0) return; if (choice.MaxOccurs > 1) multiValue = true; XmlTypeMapMemberElement member; if (multiValue) { member = new XmlTypeMapMemberFlatList (); member.Name = classIds.AddUnique ("Items", member); ListMap listMap = new ListMap (); listMap.ItemInfo = choices; ((XmlTypeMapMemberFlatList)member).ListMap = listMap; } else { member = new XmlTypeMapMemberElement (); member.Name = classIds.AddUnique ("Item", member); } // If all choices have the same type, use that type for the member. // If not use System.Object. // If there are at least two choices with the same type, use a choice // identifier attribute TypeData typeData = null; bool twoEqual = false; bool allEqual = true; Hashtable types = new Hashtable (); for (int n = choices.Count - 1; n >= 0; n--) { XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) choices [n]; // In some complex schemas, we may end up with several options // with the same name. It is better to ignore the extra options // than to crash. It's the best we can do, and btw it works // better than in MS.NET. if (cmap.GetElement (einfo.ElementName, einfo.Namespace, einfo.ExplicitOrder) != null || choices.IndexOfElement (einfo.ElementName, einfo.Namespace) != n) { choices.RemoveAt (n); continue; } if (types.ContainsKey (einfo.TypeData)) twoEqual = true; else types.Add (einfo.TypeData, einfo); TypeData choiceType = einfo.TypeData; if (choiceType.SchemaType == SchemaTypes.Class) { // When comparing class types, use the most generic class in the // inheritance hierarchy XmlTypeMapping choiceMap = GetTypeMapping (choiceType); BuildPendingMap (choiceMap); while (choiceMap.BaseMap != null) { choiceMap = choiceMap.BaseMap; BuildPendingMap (choiceMap); choiceType = choiceMap.TypeData; } } if (typeData == null) typeData = choiceType; else if (typeData != choiceType) allEqual = false; } if (!allEqual) typeData = TypeTranslator.GetTypeData (typeof(object)); if (twoEqual) { // Create the choice member XmlTypeMapMemberElement choiceMember = new XmlTypeMapMemberElement (); choiceMember.Ignore = true; choiceMember.Name = classIds.AddUnique (member.Name + "ElementName", choiceMember); member.ChoiceMember = choiceMember.Name; // Create the choice enum XmlTypeMapping enumMap = CreateTypeMapping (new XmlQualifiedName (member.Name + "ChoiceType", typeQName.Namespace), SchemaTypes.Enum, null); enumMap.IncludeInSchema = false; CodeIdentifiers codeIdents = new CodeIdentifiers (); EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [choices.Count]; for (int n=0; n<choices.Count; n++) { XmlTypeMapElementInfo it =(XmlTypeMapElementInfo) choices[n]; bool extraNs = (it.Namespace != null && it.Namespace != "" && it.Namespace != typeQName.Namespace); string xmlName = extraNs ? it.Namespace + ":" + it.ElementName : it.ElementName; string enumName = codeIdents.AddUnique (CodeIdentifier.MakeValid (it.ElementName), it); members [n] = new EnumMap.EnumMapMember (xmlName, enumName); } enumMap.ObjectMap = new EnumMap (members, false); choiceMember.TypeData = multiValue ? enumMap.TypeData.ListTypeData : enumMap.TypeData; choiceMember.ElementInfo.Add (CreateElementInfo (typeQName.Namespace, choiceMember, choiceMember.Name, choiceMember.TypeData, false, XmlSchemaForm.None, -1)); cmap.AddMember (choiceMember); } if (typeData == null) return; if (multiValue) typeData = typeData.ListTypeData; member.ElementInfo = choices; member.Documentation = GetDocumentation (choice); member.TypeData = typeData; cmap.AddMember (member); }
protected override void GenerateElementInfoMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName) { CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Xml.Serialization.XmlElement"); if (forceUseMemberName || einfo.ElementName != member.Name) { att.Arguments.Add(GetArg(einfo.ElementName)); } if (einfo.TypeData.FullTypeName != defaultType.FullTypeName) { att.Arguments.Add(GetTypeArg("Type", einfo.TypeData.FullTypeName)); } if (einfo.Namespace != defaultNamespace) { att.Arguments.Add(GetArg("Namespace", einfo.Namespace)); } if (einfo.Form == XmlSchemaForm.Unqualified) { att.Arguments.Add(GetEnumArg("Form", "System.Xml.Schema.XmlSchemaForm", einfo.Form.ToString())); } if (einfo.IsNullable) { att.Arguments.Add(GetArg("IsNullable", true)); } if (!TypeTranslator.IsDefaultPrimitiveTpeData(einfo.TypeData)) { att.Arguments.Add(GetArg("DataType", einfo.TypeData.XmlType)); } if (addAlwaysAttr || att.Arguments.Count > 0) { attributes.Add(att); } }
XmlMemberMapping ImportMemberMapping (string name, string ns, bool isNullable, TypeData type, XmlTypeMapping emap, int order) { XmlTypeMapMemberElement mapMem; if (type.IsListType) mapMem = new XmlTypeMapMemberList (); else mapMem = new XmlTypeMapMemberElement (); mapMem.Name = name; mapMem.TypeData = type; mapMem.ElementInfo.Add (CreateElementInfo (ns, mapMem, name, type, isNullable, XmlSchemaForm.None, emap, order)); return new XmlMemberMapping (name, ns, mapMem, encodedFormat); }
protected override void GenerateElementMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member) { if (member.ChoiceMember != null) { CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Xml.Serialization.XmlChoiceIdentifier"); att.Arguments.Add(GetArg(member.ChoiceMember)); attributes.Add(att); } if (member.Ignore) { attributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute")); } }
XmlTypeMapElementInfoList ImportAnyElementInfo (string defaultNamespace, XmlReflectionMember rmember, XmlTypeMapMemberElement member, XmlAttributes atts) { XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList(); ImportTextElementInfo (list, rmember.MemberType, member, atts, defaultNamespace); #if !MOONLIGHT // no practical anyElement support foreach (XmlAnyElementAttribute att in atts.XmlAnyElements) { XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(typeof(XmlElement))); if (att.Name.Length != 0) { elem.ElementName = XmlConvert.EncodeLocalName(att.Name); elem.Namespace = (att.Namespace != null) ? att.Namespace : ""; } else { elem.IsUnnamedAnyElement = true; elem.Namespace = defaultNamespace; if (att.Namespace != null) throw new InvalidOperationException ("The element " + rmember.MemberName + " has been attributed with an XmlAnyElementAttribute and a namespace '" + att.Namespace + "', but no name. When a namespace is supplied, a name is also required. Supply a name or remove the namespace."); } list.Add (elem); } #endif return list; }
protected override void GenerateArrayElement(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName) { XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo)member.ElementInfo[0]; CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Xml.Serialization.XmlArray"); if (forceUseMemberName || (einfo.ElementName != member.Name)) { att.Arguments.Add(GetArg("ElementName", einfo.ElementName)); } if (einfo.Namespace != defaultNamespace) { att.Arguments.Add(GetArg("Namespace", einfo.Namespace)); } if (einfo.Form == XmlSchemaForm.Unqualified) { att.Arguments.Add(MapCodeGenerator.GetEnumArg("Form", "System.Xml.Schema.XmlSchemaForm", einfo.Form.ToString())); } if (einfo.IsNullable) { att.Arguments.Add(GetArg("IsNullable", true)); } if (att.Arguments.Count > 0) { attributes.Add(att); } }
private XmlTypeMapMember CreateMapMember (Type declaringType, XmlReflectionMember rmember, string defaultNamespace) { XmlTypeMapMember mapMember; XmlAttributes atts = rmember.XmlAttributes; TypeData typeData = TypeTranslator.GetTypeData (rmember.MemberType); if (atts.XmlArray != null) { if (atts.XmlArray.Namespace != null && atts.XmlArray.Form == XmlSchemaForm.Unqualified) throw new InvalidOperationException ("XmlArrayAttribute.Form must not be Unqualified when it has an explicit Namespace value."); if (typeData.SchemaType != SchemaTypes.Array && !(typeData.SchemaType == SchemaTypes.Primitive && typeData.Type == typeof (byte []))) throw new InvalidOperationException ("XmlArrayAttribute can be applied to members of array or collection type."); } #if !MOONLIGHT if (atts.XmlAnyAttribute != null) { if ( (rmember.MemberType.FullName == "System.Xml.XmlAttribute[]") || (rmember.MemberType.FullName == "System.Xml.XmlNode[]") ) { mapMember = new XmlTypeMapMemberAnyAttribute(); } else throw new InvalidOperationException ("XmlAnyAttributeAttribute can only be applied to members of type XmlAttribute[] or XmlNode[]"); } else #endif if (atts.XmlAnyElements != null && atts.XmlAnyElements.Count > 0) { // no XmlNode type check is done here (seealso: bug #553032). XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement(); member.ElementInfo = ImportAnyElementInfo (defaultNamespace, rmember, member, atts); mapMember = member; } else if (atts.Xmlns) { XmlTypeMapMemberNamespaces mapNamespaces = new XmlTypeMapMemberNamespaces (); mapMember = mapNamespaces; } else if (atts.XmlAttribute != null) { // An attribute if (atts.XmlElements != null && atts.XmlElements.Count > 0) throw new Exception ("XmlAttributeAttribute and XmlElementAttribute cannot be applied to the same member"); XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute (); if (atts.XmlAttribute.AttributeName.Length == 0) mapAttribute.AttributeName = rmember.MemberName; else mapAttribute.AttributeName = atts.XmlAttribute.AttributeName; mapAttribute.AttributeName = XmlConvert.EncodeLocalName (mapAttribute.AttributeName); if (typeData.IsComplexType) mapAttribute.MappedType = ImportTypeMapping (typeData.Type, null, defaultNamespace); if (atts.XmlAttribute.Namespace != null && atts.XmlAttribute.Namespace != defaultNamespace) { if (atts.XmlAttribute.Form == XmlSchemaForm.Unqualified) throw new InvalidOperationException ("The Form property may not be 'Unqualified' when an explicit Namespace property is present"); mapAttribute.Form = XmlSchemaForm.Qualified; mapAttribute.Namespace = atts.XmlAttribute.Namespace; } else { mapAttribute.Form = atts.XmlAttribute.Form; if (atts.XmlAttribute.Form == XmlSchemaForm.Qualified) mapAttribute.Namespace = defaultNamespace; else mapAttribute.Namespace = ""; } typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.XmlAttribute.DataType); mapMember = mapAttribute; } else if (typeData.SchemaType == SchemaTypes.Array) { // If the member has a single XmlElementAttribute and the type is the type of the member, // then it is not a flat list if (atts.XmlElements.Count > 1 || (atts.XmlElements.Count == 1 && atts.XmlElements[0].Type != typeData.Type) || (atts.XmlText != null)) { // A flat list // check that it does not have XmlArrayAttribute if (atts.XmlArray != null) throw new InvalidOperationException ("XmlArrayAttribute cannot be used with members which also attributed with XmlElementAttribute or XmlTextAttribute."); XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList (); member.ListMap = new ListMap (); member.ListMap.ItemInfo = ImportElementInfo (declaringType, XmlConvert.EncodeLocalName (rmember.MemberName), defaultNamespace, typeData.ListItemType, member, atts); member.ElementInfo = member.ListMap.ItemInfo; member.ListMap.ChoiceMember = member.ChoiceMember; mapMember = member; } else { // A list XmlTypeMapMemberList member = new XmlTypeMapMemberList (); // Creates an ElementInfo that identifies the array instance. member.ElementInfo = new XmlTypeMapElementInfoList(); XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, typeData); elem.ElementName = XmlConvert.EncodeLocalName((atts.XmlArray != null && atts.XmlArray.ElementName.Length != 0) ? atts.XmlArray.ElementName : rmember.MemberName); // note that it could be changed below (when Form is Unqualified) elem.Namespace = (atts.XmlArray != null && atts.XmlArray.Namespace != null) ? atts.XmlArray.Namespace : defaultNamespace; elem.MappedType = ImportListMapping (rmember.MemberType, null, elem.Namespace, atts, 0); elem.IsNullable = (atts.XmlArray != null) ? atts.XmlArray.IsNullable : false; elem.Form = (atts.XmlArray != null) ? atts.XmlArray.Form : XmlSchemaForm.Qualified; // This is a bit tricky, but is done // after filling descendant members, so // that array items could be serialized // with proper namespace. if (atts.XmlArray != null && atts.XmlArray.Form == XmlSchemaForm.Unqualified) elem.Namespace = String.Empty; member.ElementInfo.Add (elem); mapMember = member; } } else { // An element XmlTypeMapMemberElement member = new XmlTypeMapMemberElement (); member.ElementInfo = ImportElementInfo (declaringType, XmlConvert.EncodeLocalName(rmember.MemberName), defaultNamespace, rmember.MemberType, member, atts); mapMember = member; } mapMember.DefaultValue = GetDefaultValue (typeData, atts.XmlDefaultValue); mapMember.TypeData = typeData; mapMember.Name = rmember.MemberName; mapMember.IsReturnValue = rmember.IsReturnValue; return mapMember; }
void ImportSimpleContent (XmlQualifiedName typeQName, XmlTypeMapping map, XmlSchemaSimpleContent content, CodeIdentifiers classIds, bool isMixed) { ClassMap cmap = (ClassMap)map.ObjectMap; XmlQualifiedName qname = GetContentBaseType (content.Content); XmlTypeMapMemberElement member = new XmlTypeMapMemberElement (); member.Name = classIds.AddUnique("Value", member); member.TypeData = FindBuiltInType (qname); member.ElementInfo.Add (CreateTextElementInfo (typeQName.Namespace, member, member.TypeData)); member.IsXmlTextCollector = true; cmap.AddMember (member); XmlSchemaSimpleContentExtension ext = content.Content as XmlSchemaSimpleContentExtension; if (ext != null) ImportAttributes (typeQName, cmap, ext.Attributes, ext.AnyAttribute, classIds); }
protected override void GenerateElementInfoMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName) { CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Xml.Serialization.SoapElement"); if (forceUseMemberName || einfo.ElementName != member.Name) att.Arguments.Add (GetArg (einfo.ElementName)); // if (einfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", true)); MS seems to ignore this if (!TypeTranslator.IsDefaultPrimitiveTpeData(einfo.TypeData)) att.Arguments.Add (GetArg ("DataType",einfo.TypeData.XmlType)); if (addAlwaysAttr || att.Arguments.Count > 0) attributes.Add (att); }
private XmlTypeMapMember CreateMapMember(XmlReflectionMember rmember, string defaultNamespace) { XmlTypeMapMember mapMember; SoapAttributes atts = rmember.SoapAttributes; TypeData typeData = TypeTranslator.GetTypeData(rmember.MemberType); if (atts.SoapAttribute != null) { // An attribute if (atts.SoapElement != null) { throw new Exception("SoapAttributeAttribute and SoapElementAttribute cannot be applied to the same member"); } XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute(); if (atts.SoapAttribute.AttributeName == null) { mapAttribute.AttributeName = rmember.MemberName; } else { mapAttribute.AttributeName = atts.SoapAttribute.AttributeName; } mapAttribute.Namespace = (atts.SoapAttribute.Namespace != null) ? atts.SoapAttribute.Namespace : ""; if (typeData.IsComplexType) { mapAttribute.MappedType = ImportTypeMapping(typeData.Type, defaultNamespace); } typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.SoapAttribute.DataType); mapMember = mapAttribute; } else { if (typeData.SchemaType == SchemaTypes.Array) { mapMember = new XmlTypeMapMemberList(); } else { mapMember = new XmlTypeMapMemberElement(); } if (atts.SoapElement != null && atts.SoapElement.DataType != null) { typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.SoapElement.DataType); } // Creates an ElementInfo that identifies the element XmlTypeMapElementInfoList infoList = new XmlTypeMapElementInfoList(); XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(mapMember, typeData); elem.ElementName = (atts.SoapElement != null && atts.SoapElement.ElementName != null) ? atts.SoapElement.ElementName : rmember.MemberName; elem.Namespace = string.Empty; elem.IsNullable = (atts.SoapElement != null) ? atts.SoapElement.IsNullable : false; if (typeData.IsComplexType) { elem.MappedType = ImportTypeMapping(typeData.Type, defaultNamespace); } infoList.Add(elem); ((XmlTypeMapMemberElement)mapMember).ElementInfo = infoList; } mapMember.TypeData = typeData; mapMember.Name = rmember.MemberName; mapMember.IsReturnValue = rmember.IsReturnValue; return(mapMember); }