public void RegisterClrType (XmlTypeMapping map, Type type, string ns) { if (type == typeof(object)) ns = ""; string mapKey = type.FullName + "/" + ns; if (!_clrTypes.ContainsKey (mapKey)) _clrTypes.Add (mapKey, map); }
/// <include file='doc\XmlCodeExporter.uex' path='docs/doc[@for="XmlCodeExporter.ExportTypeMapping"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportTypeMapping(XmlTypeMapping xmlTypeMapping) { xmlTypeMapping.CheckShallow(); CheckScope(xmlTypeMapping.Scope); if (xmlTypeMapping.Accessor.Any) throw new InvalidOperationException(Res.GetString(Res.XmlIllegalWildcard)); ExportElement(xmlTypeMapping.Accessor); }
/// <include file='doc\XmlSchemaExporter.uex' path='docs/doc[@for="XmlSchemaExporter.ExportTypeMapping"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void ExportTypeMapping(XmlTypeMapping xmlTypeMapping) { xmlTypeMapping.CheckShallow(); CheckScope(xmlTypeMapping.Scope); ExportElement(xmlTypeMapping.Accessor); ExportRootIfNecessary(xmlTypeMapping.Scope); }
public static XmlSerializer Create(XmlTypeMapping xmlTypeMapping) { XmlSerializer xs = _factory.CreateSerializer(xmlTypeMapping); if (xs == null) xs = new XmlSerializer(xmlTypeMapping); return xs; }
public static void Print(XmlTypeMapping tm) { Console.WriteLine("/XmlTypeMapping:"); Console.WriteLine("ElementName: {0} ", tm.ElementName); Console.WriteLine("Namespace: {0} ", tm.Namespace); Console.WriteLine("TypeName: {0} ", tm.TypeName); Console.WriteLine("FullTypeName: {0} ", tm.TypeFullName); }
public void AddMappingMetadata (CodeAttributeDeclarationCollection metadata, XmlTypeMapping member, string ns) { if (member.Namespace != ns && member.Namespace != "") { CodeAttributeDeclaration ratt = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlRoot"); ratt.Arguments.Add (MapCodeGenerator.GetArg (member.ElementName)); ratt.Arguments.Add (MapCodeGenerator.GetArg ("Namespace", member.Namespace)); ratt.Arguments.Add (MapCodeGenerator.GetArg ("IsNullable", member.IsNullable)); metadata.Add (ratt); } }
public XmlSerializer CreateSerializer (XmlTypeMapping xmlTypeMapping) { lock (serializersBySource) { XmlSerializer ser = (XmlSerializer) serializersBySource [xmlTypeMapping.Source]; if (ser == null) { ser = new XmlSerializer (xmlTypeMapping); serializersBySource [xmlTypeMapping.Source] = ser; } return ser; } }
object ReadXmlSerializableElement(XmlTypeMapping typeMap, bool isNullable) { Reader.MoveToContent(); if (Reader.NodeType == XmlNodeType.Element) { if (Reader.LocalName == typeMap.ElementName && Reader.NamespaceURI == typeMap.Namespace) { object ob = Activator.CreateInstance(typeMap.TypeData.Type, true); return(ReadSerializable((IXmlSerializable)ob)); } else { throw CreateUnknownNodeException(); } } else { UnknownNode(null); return(null); } }
protected override void InitCallbacks() { ArrayList relatedMaps = this._typeMap.RelatedMaps; if (relatedMaps != null) { foreach (object obj in relatedMaps) { XmlTypeMapping xmlTypeMapping = (XmlTypeMapping)obj; XmlSerializationWriterInterpreter.CallbackInfo @object = new XmlSerializationWriterInterpreter.CallbackInfo(this, xmlTypeMapping); if (xmlTypeMapping.TypeData.SchemaType == SchemaTypes.Enum) { base.AddWriteCallback(xmlTypeMapping.TypeData.Type, xmlTypeMapping.XmlType, xmlTypeMapping.Namespace, new XmlSerializationWriteCallback(@object.WriteEnum)); } else { base.AddWriteCallback(xmlTypeMapping.TypeData.Type, xmlTypeMapping.XmlType, xmlTypeMapping.Namespace, new XmlSerializationWriteCallback(@object.WriteObject)); } } } }
void ExportEnumCode(XmlTypeMapping map) { if (IsMapExported(map)) { return; } CodeTypeDeclaration codeEnum = new CodeTypeDeclaration(map.TypeData.TypeName); SetMapExported(map, codeEnum); codeEnum.Attributes = MemberAttributes.Public; codeEnum.IsEnum = true; AddCodeType(codeEnum, map.Documentation); GenerateEnum(map, codeEnum); EnumMap emap = (EnumMap)map.ObjectMap; if (emap.IsFlags) { codeEnum.CustomAttributes.Add(new CodeAttributeDeclaration("System.Flags")); } int flag = 1; foreach (EnumMap.EnumMapMember emem in emap.Members) { CodeMemberField codeField = new CodeMemberField("", emem.EnumName); if (emap.IsFlags) { codeField.InitExpression = new CodePrimitiveExpression(flag); flag *= 2; } AddComments(codeField, emem.Documentation); GenerateEnumItem(codeField, emem); codeEnum.Members.Add(codeField); } }
void ExportEnumSchema(XmlTypeMapping map) { if (IsMapExported(map)) { return; } SetMapExported(map); XmlSchema schema = GetSchema(map.XmlTypeNamespace); XmlSchemaSimpleType stype = new XmlSchemaSimpleType(); stype.Name = map.ElementName; schema.Items.Add(stype); XmlSchemaSimpleTypeRestriction rest = new XmlSchemaSimpleTypeRestriction(); rest.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); EnumMap emap = (EnumMap)map.ObjectMap; foreach (EnumMap.EnumMapMember emem in emap.Members) { XmlSchemaEnumerationFacet ef = new XmlSchemaEnumerationFacet(); ef.Value = emem.XmlName; rest.Facets.Add(ef); } if (emap.IsFlags) { XmlSchemaSimpleTypeList slist = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType restrictionType = new XmlSchemaSimpleType(); restrictionType.Content = rest; slist.ItemType = restrictionType; stype.Content = slist; } else { stype.Content = rest; } }
/// <include file='doc\XmlSerializerFactory.uex' path='docs/doc[@for="XmlSerializerFactory.CreateSerializer1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlSerializer CreateSerializer(Type type, string defaultNamespace) { if (type == null) { throw new ArgumentNullException(nameof(type)); } TempAssembly tempAssembly = s_cache[defaultNamespace, type]; XmlTypeMapping mapping = null; if (tempAssembly == null) { lock (s_cache) { tempAssembly = s_cache[defaultNamespace, type]; if (tempAssembly == null) { XmlSerializerImplementation contract; Assembly assembly = TempAssembly.LoadGeneratedAssembly(type, defaultNamespace, out contract); if (assembly == null) { // need to reflect and generate new serialization assembly XmlReflectionImporter importer = new XmlReflectionImporter(defaultNamespace); mapping = importer.ImportTypeMapping(type, null, defaultNamespace); tempAssembly = XmlSerializer.GenerateTempAssembly(mapping, type, defaultNamespace); } else { tempAssembly = new TempAssembly(contract); } s_cache.Add(defaultNamespace, type, tempAssembly); } } } if (mapping == null) { mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace); } return((XmlSerializer)tempAssembly.Contract.GetSerializer(type)); }
private void GenerateTypeElement(object o, XmlTypeMapping xmlMapping) { ElementAccessor element = xmlMapping.Accessor; TypeMapping mapping = element.Mapping; WriteStartDocument(); if (o == null) { if (element.IsNullable) { if (mapping.IsSoap) { throw new PlatformNotSupportedException(); } else { WriteNullTagLiteral(element.Name, (element.Form == XmlSchemaForm.Qualified ? element.Namespace : "")); } } else { WriteEmptyTag(element.Name, (element.Form == XmlSchemaForm.Qualified ? element.Namespace : "")); } return; } if (!mapping.TypeDesc.IsValueType && !mapping.TypeDesc.Type.GetTypeInfo().IsPrimitive) { TopLevelElement(); } WriteMember(o, null, new ElementAccessor[] { element }, null, null, mapping.TypeDesc, !element.IsSoap, xmlMapping); if (mapping.IsSoap) { WriteReferencedElements(); } }
private string GetMapKey(XmlTypeMapping map) { if (map.TypeData.IsListType) { return(string.Concat(new string[] { this.GetArrayKeyName(map.TypeData), " ", map.XmlType, " ", map.XmlTypeNamespace })); } return(string.Concat(new string[] { map.TypeData.FullTypeName, " ", map.XmlType, " ", map.XmlTypeNamespace })); }
private void GenerateTypeElement(object o, XmlTypeMapping xmlMapping) { ElementAccessor element = xmlMapping.Accessor; TypeMapping mapping = element.Mapping; WriteStartDocument(); if (o == null) { if (element.IsNullable) { if (mapping.IsSoap) { throw new PlatformNotSupportedException(); } else { WriteNullTagLiteral(element.Name, (element.Form == XmlSchemaForm.Qualified ? element.Namespace : "")); } } else { WriteEmptyTag(element.Name, (element.Form == XmlSchemaForm.Qualified ? element.Namespace : "")); } return; } if (!mapping.TypeDesc.IsValueType && !mapping.TypeDesc.Type.GetTypeInfo().IsPrimitive) { TopLevelElement(); } WriteMember(o, null, new ElementAccessor[] { element }, null, null, mapping.TypeDesc, !element.IsSoap, xmlMapping); if (mapping.IsSoap) { throw new PlatformNotSupportedException(); } }
protected override void GenerateClass(XmlTypeMapping map, CodeTypeDeclaration codeClass, bool isTopLevel) { CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Xml.Serialization.XmlTypeAttribute"); if (map.XmlType != map.TypeData.TypeName) { att.Arguments.Add(GetArg(map.XmlType)); } if (map.XmlTypeNamespace != "") { att.Arguments.Add(GetArg("Namespace", map.XmlTypeNamespace)); } if (!map.IncludeInSchema) { att.Arguments.Add(GetArg("IncludeInSchema", false)); } AddCustomAttribute(codeClass, att, false); CodeAttributeDeclaration ratt = new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute"); if (map.ElementName != map.XmlType) { ratt.Arguments.Add(GetArg(map.ElementName)); } if (isTopLevel) { ratt.Arguments.Add(GetArg("Namespace", map.Namespace)); ratt.Arguments.Add(GetArg("IsNullable", map.IsNullable)); } else { if (map.Namespace != "") { ratt.Arguments.Add(GetArg("Namespace", map.Namespace)); } } AddCustomAttribute(codeClass, ratt, isTopLevel); }
XmlTypeMapping ImportEnumMapping(TypeData typeData, string defaultNamespace) { Type type = typeData.Type; XmlTypeMapping map = helper.GetRegisteredClrType(type, GetTypeNamespace(typeData, defaultNamespace)); if (map != null) { return(map); } ReflectionHelper.CheckSerializableType(type, false); map = CreateTypeMapping(typeData, null, defaultNamespace); helper.RegisterClrType(map, type, map.Namespace); map.MultiReferenceType = true; string [] names = Enum.GetNames(type); EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember[names.Length]; for (int n = 0; n < names.Length; n++) { FieldInfo field = type.GetField(names[n]); string xmlName = names[n]; object[] atts = field.GetCustomAttributes(typeof(SoapEnumAttribute), false); if (atts.Length > 0) { xmlName = ((SoapEnumAttribute)atts[0]).Name; } long value = ((IConvertible)field.GetValue(null)).ToInt64(CultureInfo.InvariantCulture); members[n] = new EnumMap.EnumMapMember(XmlConvert.EncodeLocalName(xmlName), names[n], value); } bool isFlags = type.IsDefined(typeof(FlagsAttribute), false); map.ObjectMap = new EnumMap(members, isFlags); ImportTypeMapping(typeof(object), defaultNamespace).DerivedTypes.Add(map); return(map); }
private void ExportEnumSchema(XmlTypeMapping map) { if (this.IsMapExported(map)) { return; } this.SetMapExported(map); XmlSchema schema = this.GetSchema(map.XmlTypeNamespace); XmlSchemaSimpleType xmlSchemaSimpleType = new XmlSchemaSimpleType(); xmlSchemaSimpleType.Name = map.ElementName; schema.Items.Add(xmlSchemaSimpleType); XmlSchemaSimpleTypeRestriction xmlSchemaSimpleTypeRestriction = new XmlSchemaSimpleTypeRestriction(); xmlSchemaSimpleTypeRestriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); EnumMap enumMap = (EnumMap)map.ObjectMap; foreach (EnumMap.EnumMapMember enumMapMember in enumMap.Members) { XmlSchemaEnumerationFacet xmlSchemaEnumerationFacet = new XmlSchemaEnumerationFacet(); xmlSchemaEnumerationFacet.Value = enumMapMember.XmlName; xmlSchemaSimpleTypeRestriction.Facets.Add(xmlSchemaEnumerationFacet); } if (enumMap.IsFlags) { xmlSchemaSimpleType.Content = new XmlSchemaSimpleTypeList { ItemType = new XmlSchemaSimpleType { Content = xmlSchemaSimpleTypeRestriction } }; } else { xmlSchemaSimpleType.Content = xmlSchemaSimpleTypeRestriction; } }
internal XmlTypeMapping GetRealTypeMap(Type objectType) { if (TypeData.SchemaType == SchemaTypes.Enum) { return(this); } // Returns the map for a subtype of this map's type if (TypeData.Type == objectType) { return(this); } for (int n = 0; n < _derivedTypes.Count; n++) { XmlTypeMapping map = (XmlTypeMapping)_derivedTypes[n]; if (map.TypeData.Type == objectType) { return(map); } } return(null); }
void ExportMapCode(XmlTypeMapping map, bool isTopLevel) { switch (map.TypeData.SchemaType) { case SchemaTypes.Enum: ExportEnumCode(map, isTopLevel); break; case SchemaTypes.Array: ExportArrayCode(map); break; case SchemaTypes.Class: ExportClassCode(map, isTopLevel); break; case SchemaTypes.XmlSerializable: case SchemaTypes.XmlNode: case SchemaTypes.Primitive: // Ignore break; } }
private object GenerateTypeElement(XmlTypeMapping xmlTypeMapping) { ElementAccessor element = xmlTypeMapping.Accessor; TypeMapping mapping = element.Mapping; Reader.MoveToContent(); MemberMapping member = new MemberMapping(); member.TypeDesc = mapping.TypeDesc; member.Elements = new ElementAccessor[] { element }; UnknownNodeAction elementElseAction = UnknownNodeAction.CreateUnknownNodeException; UnknownNodeAction elseAction = UnknownNodeAction.ReadUnknownNode; object o = null; Member tempMember = null; var currentMember = new Member(member); WriteMemberElements(ref o, null /*collectionMember*/, out tempMember, new Member[] { currentMember }, elementElseAction, elseAction, element.Any ? currentMember : null, null, xmlTypeMapping); return(o); }
private object ReadListString(XmlTypeMapping typeMap, string values) { Type type = typeMap.TypeData.Type; ListMap listMap = (ListMap)typeMap.ObjectMap; values = values.Trim(); if (values == string.Empty) { return(Array.CreateInstance(type.GetElementType(), 0)); } string[] array = values.Split(new char[] { ' ' }); Array array2 = Array.CreateInstance(type.GetElementType(), array.Length); XmlTypeMapElementInfo xmlTypeMapElementInfo = (XmlTypeMapElementInfo)listMap.ItemInfo[0]; for (int i = 0; i < array.Length; i++) { array2.SetValue(this.GetValueFromXmlString(array[i], xmlTypeMapElementInfo.TypeData, xmlTypeMapElementInfo.MappedType), i); } return(array2); }
public XmlSerializer CreateSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace, string location, Evidence evidence) { if (type == null) { throw new ArgumentNullException("type"); } if (location != null || evidence != null) { DemandForUserLocationOrEvidence(); } XmlReflectionImporter importer = new XmlReflectionImporter(overrides, defaultNamespace); for (int i = 0; i < extraTypes.Length; i++) { importer.IncludeType(extraTypes[i]); } XmlTypeMapping mapping = importer.ImportTypeMapping(type, root, defaultNamespace); TempAssembly tempAssembly = XmlSerializer.GenerateTempAssembly(mapping, type, defaultNamespace, location, evidence); return((XmlSerializer)tempAssembly.Contract.TypedSerializers[mapping.Key]); }
object ReadEncodedObject(XmlTypeMapping typeMap) { object ob = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { if (Reader.LocalName == typeMap.ElementName && Reader.NamespaceURI == typeMap.Namespace) { ob = ReadReferencedElement(); } else { throw CreateUnknownNodeException(); } } else { UnknownNode(null); } ReadReferencedElements(); return(ob); }
object ReadListString(XmlTypeMapping typeMap, string values) { Type listType = typeMap.TypeData.Type; ListMap listMap = (ListMap)typeMap.ObjectMap; values = values.Trim(); if (values == string.Empty) { return(Array.CreateInstance(listType.GetElementType(), 0)); } string[] valueArray = values.Split(' '); Array list = Array.CreateInstance(listType.GetElementType(), valueArray.Length); XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0]; for (int index = 0; index < valueArray.Length; index++) { list.SetValue(GetValueFromXmlString(valueArray[index], info.TypeData, info.MappedType), index); } return(list); }
public XmlSerializer CreateSerializer(Type type, string defaultNamespace) { if (type == null) { throw new ArgumentNullException("type"); } TempAssembly assembly = cache[defaultNamespace, type]; XmlTypeMapping xmlMapping = null; if (assembly == null) { lock (cache) { assembly = cache[defaultNamespace, type]; if (assembly == null) { XmlSerializerImplementation implementation; if (TempAssembly.LoadGeneratedAssembly(type, defaultNamespace, out implementation) == null) { xmlMapping = new XmlReflectionImporter(defaultNamespace).ImportTypeMapping(type, null, defaultNamespace); assembly = XmlSerializer.GenerateTempAssembly(xmlMapping, type, defaultNamespace); } else { assembly = new TempAssembly(implementation); } cache.Add(defaultNamespace, type, assembly); } } } if (xmlMapping == null) { xmlMapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace); } return(assembly.Contract.GetSerializer(type)); }
public Exception CreateError(XmlTypeMapping map, string message) { return(new InvalidOperationException("There was an error reflecting '" + map.TypeFullName + "': " + message)); }
protected override void GenerateEnum (XmlTypeMapping map, CodeTypeDeclaration codeEnum) { CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Xml.Serialization.SoapType"); if (map.XmlType != map.TypeData.TypeName) att.Arguments.Add (GetArg (map.XmlType)); if (map.XmlTypeNamespace != "") att.Arguments.Add (GetArg ("Namespace", map.XmlTypeNamespace)); AddCustomAttribute (codeEnum, att, false); }
public void ExportTypeMapping(XmlTypeMapping xmlTypeMapping) { codeGenerator.ExportTypeMapping(xmlTypeMapping, true); }
void RegisterMapFixup (XmlTypeMapping map, XmlQualifiedName typeQName, XmlSchemaComplexType stype) { // This check is introduced for bug #650117, but might be too wide to catch erroneous cases... if (fixup_registered_types.Contains (stype)) throw new InvalidOperationException (String.Format ("Circular dependency for schema type {0} in namespace {1}", map.ElementName, map.Namespace)); fixup_registered_types.Add (stype); MapFixup fixup = new MapFixup (); fixup.Map = map; fixup.SchemaType = stype; fixup.TypeName = typeQName; pendingMaps.Enqueue (fixup); }
void SetElementExported(XmlTypeMapping map) { exportedElements [GetMapKey(map)] = map; }
void BuildClassMap (XmlTypeMapping map, XmlQualifiedName typeQName, XmlSchemaComplexType stype) { CodeIdentifiers classIds = new CodeIdentifiers(); classIds.AddReserved (map.TypeData.TypeName); ClassMap cmap = new ClassMap (); map.ObjectMap = cmap; bool isMixed = stype.IsMixed; if (stype.Particle != null) ImportParticleComplexContent (typeQName, cmap, stype.Particle, classIds, isMixed); else { if (stype.ContentModel is XmlSchemaSimpleContent) { ImportSimpleContent (typeQName, map, (XmlSchemaSimpleContent)stype.ContentModel, classIds, isMixed); } else if (stype.ContentModel is XmlSchemaComplexContent) { ImportComplexContent (typeQName, map, (XmlSchemaComplexContent)stype.ContentModel, classIds, isMixed); } } ImportAttributes (typeQName, cmap, stype.Attributes, stype.AnyAttribute, classIds); ImportExtensionTypes (typeQName); if (isMixed) AddTextMember (typeQName, cmap, classIds); AddObjectDerivedMap (map); }
void SetMapBaseType (XmlTypeMapping map, Type baseType) { // This method sets the base type for a given map. // If the map already inherits from this type, it does nothing. // Fiirst of all, check if the map already inherits from baseType XmlTypeMapping topMap = null; while (map != null) { if (map.TypeData.Type == baseType) return; topMap = map; map = map.BaseMap; } // Does not have the requested base type. // Then, get/create a map for that base type. XmlTypeMapping baseMap = ReflectType (baseType); // Add this map as a derived map of the base map topMap.BaseMap = baseMap; baseMap.DerivedTypes.Add (topMap); baseMap.DerivedTypes.AddRange (topMap.DerivedTypes); // Now add the base type fields to all derived maps ClassMap baseClassMap = (ClassMap)baseMap.ObjectMap; ClassMap cmap = (ClassMap)topMap.ObjectMap; foreach (XmlTypeMapMember member in baseClassMap.AllMembers) cmap.AddMember (member); foreach (XmlTypeMapping derivedMap in topMap.DerivedTypes) { cmap = (ClassMap)derivedMap.ObjectMap; foreach (XmlTypeMapMember member in baseClassMap.AllMembers) cmap.AddMember (member); } }
protected override void GenerateClassInclude(CodeAttributeDeclarationCollection attributes, XmlTypeMapping map) { CodeAttributeDeclaration iatt = new CodeAttributeDeclaration("System.Xml.Serialization.SoapInclude"); iatt.Arguments.Add(new CodeAttributeArgument(new CodeTypeOfExpression(map.TypeData.FullTypeName))); attributes.Add(iatt); }
XmlQualifiedName ExportArraySchema(XmlTypeMapping map, string defaultNamespace) { ListMap lmap = (ListMap)map.ObjectMap; if (encodedFormat) { string name, ns, schemaNs; lmap.GetArrayType(-1, out name, out ns); if (ns == XmlSchema.Namespace) { schemaNs = defaultNamespace; } else { schemaNs = ns; } if (IsMapExported(map)) { return(new XmlQualifiedName(lmap.GetSchemaArrayName(), schemaNs)); } SetMapExported(map); XmlSchema schema = GetSchema(schemaNs); XmlSchemaComplexType stype = new XmlSchemaComplexType(); stype.Name = lmap.GetSchemaArrayName(); schema.Items.Add(stype); XmlSchemaComplexContent content = new XmlSchemaComplexContent(); content.IsMixed = false; stype.ContentModel = content; XmlSchemaComplexContentRestriction rest = new XmlSchemaComplexContentRestriction(); content.Content = rest; rest.BaseTypeName = new XmlQualifiedName("Array", XmlSerializer.EncodingNamespace); XmlSchemaAttribute at = new XmlSchemaAttribute(); rest.Attributes.Add(at); at.RefName = new XmlQualifiedName("arrayType", XmlSerializer.EncodingNamespace); XmlAttribute arrayType = Document.CreateAttribute("arrayType", XmlSerializer.WsdlNamespace); arrayType.Value = ns + (ns != "" ? ":" : "") + name; at.UnhandledAttributes = new XmlAttribute [] { arrayType }; ImportNamespace(schema, XmlSerializer.WsdlNamespace); XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo)lmap.ItemInfo[0]; if (einfo.MappedType != null) { switch (einfo.TypeData.SchemaType) { case SchemaTypes.Enum: ExportEnumSchema(einfo.MappedType); break; case SchemaTypes.Array: ExportArraySchema(einfo.MappedType, schemaNs); break; case SchemaTypes.Class: ExportClassSchema(einfo.MappedType); break; } } return(new XmlQualifiedName(lmap.GetSchemaArrayName(), schemaNs)); } else { if (IsMapExported(map)) { return(new XmlQualifiedName(map.XmlType, map.XmlTypeNamespace)); } SetMapExported(map); XmlSchema schema = GetSchema(map.XmlTypeNamespace); XmlSchemaComplexType stype = new XmlSchemaComplexType(); stype.Name = map.ElementName; schema.Items.Add(stype); XmlSchemaParticle spart = GetSchemaArrayElement(schema, lmap.ItemInfo); if (spart is XmlSchemaChoice) { stype.Particle = spart; } else { XmlSchemaSequence seq = new XmlSchemaSequence(); seq.Items.Add(spart); stype.Particle = seq; } return(new XmlQualifiedName(map.XmlType, map.XmlTypeNamespace)); } }
void ExportMembersMapSchema(XmlSchema schema, ClassMap map, XmlTypeMapping baseMap, XmlSchemaObjectCollection outAttributes, out XmlSchemaSequence particle, out XmlSchemaAnyAttribute anyAttribute) { particle = null; XmlSchemaSequence seq = new XmlSchemaSequence(); ICollection members = map.ElementMembers; if (members != null && !map.HasSimpleContent) { foreach (XmlTypeMapMemberElement member in members) { if (baseMap != null && DefinedInBaseMap(baseMap, member)) { continue; } Type memType = member.GetType(); if (memType == typeof(XmlTypeMapMemberFlatList)) { XmlSchemaParticle part = GetSchemaArrayElement(schema, member.ElementInfo); if (part != null) { seq.Items.Add(part); } } else if (memType == typeof(XmlTypeMapMemberAnyElement)) { seq.Items.Add(GetSchemaArrayElement(schema, member.ElementInfo)); } else if (memType == typeof(XmlTypeMapMemberElement)) { GetSchemaElement(schema, (XmlTypeMapElementInfo)member.ElementInfo [0], member.DefaultValue, true, new XmlSchemaObjectContainer(seq)); } else { GetSchemaElement(schema, (XmlTypeMapElementInfo)member.ElementInfo[0], true, new XmlSchemaObjectContainer(seq)); } } } if (seq.Items.Count > 0) { particle = seq; } // Write attributes ICollection attributes = map.AttributeMembers; if (attributes != null) { foreach (XmlTypeMapMemberAttribute attr in attributes) { if (baseMap != null && DefinedInBaseMap(baseMap, attr)) { continue; } outAttributes.Add(GetSchemaAttribute(schema, attr, true)); } } XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember; if (anyAttrMember != null) { anyAttribute = new XmlSchemaAnyAttribute(); } else { anyAttribute = null; } }
bool HasMixedContent(XmlTypeMapping map) { ClassMap cmap = (ClassMap)map.ObjectMap; return(cmap.XmlTextCollector != null && (map.BaseMap == null || !DefinedInBaseMap(map.BaseMap, cmap.XmlTextCollector))); }
void ExportClassSchema(XmlTypeMapping map) { if (IsMapExported(map)) { return; } SetMapExported(map); if (map.TypeData.Type == typeof(object)) { foreach (XmlTypeMapping dmap in map.DerivedTypes) { if (dmap.TypeData.SchemaType == SchemaTypes.Class) { ExportClassSchema(dmap); } } return; } XmlSchema schema = GetSchema(map.XmlTypeNamespace); XmlSchemaComplexType stype = new XmlSchemaComplexType(); stype.Name = map.XmlType; schema.Items.Add(stype); ClassMap cmap = (ClassMap)map.ObjectMap; if (cmap.HasSimpleContent) { XmlSchemaSimpleContent simple = new XmlSchemaSimpleContent(); stype.ContentModel = simple; XmlSchemaSimpleContentExtension ext = new XmlSchemaSimpleContentExtension(); simple.Content = ext; XmlSchemaSequence particle; XmlSchemaAnyAttribute anyAttribute; ExportMembersMapSchema(schema, cmap, map.BaseMap, ext.Attributes, out particle, out anyAttribute); ext.AnyAttribute = anyAttribute; if (map.BaseMap == null) { ext.BaseTypeName = cmap.SimpleContentBaseType; } else { ext.BaseTypeName = new XmlQualifiedName(map.BaseMap.XmlType, map.BaseMap.XmlTypeNamespace); ImportNamespace(schema, map.BaseMap.XmlTypeNamespace); ExportClassSchema(map.BaseMap); } } else if (map.BaseMap != null && map.BaseMap.IncludeInSchema) { XmlSchemaComplexContent cstype = new XmlSchemaComplexContent(); XmlSchemaComplexContentExtension ext = new XmlSchemaComplexContentExtension(); ext.BaseTypeName = new XmlQualifiedName(map.BaseMap.XmlType, map.BaseMap.XmlTypeNamespace); cstype.Content = ext; stype.ContentModel = cstype; XmlSchemaSequence particle; XmlSchemaAnyAttribute anyAttribute; ExportMembersMapSchema(schema, cmap, map.BaseMap, ext.Attributes, out particle, out anyAttribute); ext.Particle = particle; ext.AnyAttribute = anyAttribute; stype.IsMixed = HasMixedContent(map); cstype.IsMixed = BaseHasMixedContent(map); ImportNamespace(schema, map.BaseMap.XmlTypeNamespace); ExportClassSchema(map.BaseMap); } else { XmlSchemaSequence particle; XmlSchemaAnyAttribute anyAttribute; ExportMembersMapSchema(schema, cmap, map.BaseMap, stype.Attributes, out particle, out anyAttribute); stype.Particle = particle; stype.AnyAttribute = anyAttribute; stype.IsMixed = cmap.XmlTextCollector != null; } foreach (XmlTypeMapping dmap in map.DerivedTypes) { if (dmap.TypeData.SchemaType == SchemaTypes.Class) { ExportClassSchema(dmap); } } }
XmlTypeMapping CreateSystemMap (TypeData typeData) { XmlTypeMapping map = new XmlTypeMapping (typeData.XmlType, XmlSchema.Namespace, typeData, typeData.XmlType, XmlSchema.Namespace); map.IncludeInSchema = false; map.ObjectMap = new ClassMap (); dataMappedTypes [typeData] = map; return map; }
void RegisterDerivedMap (XmlTypeMapping map, XmlTypeMapping derivedMap) { map.DerivedTypes.Add (derivedMap); map.DerivedTypes.AddRange (derivedMap.DerivedTypes); if (map.BaseMap != null) RegisterDerivedMap (map.BaseMap, derivedMap); else { XmlTypeMapping obmap = ImportTypeMapping (typeof(object)); if (obmap != map) obmap.DerivedTypes.Add (derivedMap); } }
void RegisterTypeMapping (XmlQualifiedName qname, TypeData typeData, XmlTypeMapping map) { // Primitive types with a forced base class are stored in a different table. // In this way it is possible to have two maps for primitive types: one with // the forced base class (returned by ImportDerivedTypeMapping) and one // with the regular primitive map. dataMappedTypes [typeData] = map; if (IsPrimitiveTypeNamespace (qname.Namespace) && !map.IsSimpleType) primitiveDerivedMappedTypes [qname] = map; else mappedTypes [qname] = map; }
public XmlSerializer CreateSerializer(XmlTypeMapping xmlTypeMapping) { return(new XmlSerializer(xmlTypeMapping)); }
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); }
/// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer5"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlSerializer(XmlTypeMapping xmlTypeMapping) { tempAssembly = GenerateTempAssembly(xmlTypeMapping); this.mapping = xmlTypeMapping; }
void BuildPendingMap (XmlTypeMapping map) { if (map.ObjectMap != null) return; foreach (MapFixup fixup in pendingMaps) { if (fixup.Map == map) { BuildClassMap (fixup.Map, fixup.TypeName, fixup.SchemaType); return; } } throw new InvalidOperationException ("Can't complete map of type " + map.XmlType + " : " + map.Namespace); }
void SetMapExported(XmlTypeMapping map) { exportedMaps [GetMapKey(map)] = map; }
XmlTypeMapping CreateTypeMapping (TypeData typeData, XmlRootAttribute root, string defaultXmlType, string defaultNamespace) { string rootNamespace = defaultNamespace; string typeNamespace = null; string elementName; bool includeInSchema = true; XmlAttributes atts = null; bool nullable = CanBeNull (typeData); if (defaultXmlType == null) defaultXmlType = typeData.XmlType; if (!typeData.IsListType) { if (attributeOverrides != null) atts = attributeOverrides[typeData.Type]; if (atts != null && typeData.SchemaType == SchemaTypes.Primitive) throw new InvalidOperationException ("XmlRoot and XmlType attributes may not be specified for the type " + typeData.FullTypeName); } if (atts == null) atts = new XmlAttributes (typeData.Type); if (atts.XmlRoot != null && root == null) root = atts.XmlRoot; if (atts.XmlType != null) { if (atts.XmlType.Namespace != null) typeNamespace = atts.XmlType.Namespace; if (atts.XmlType.TypeName != null && atts.XmlType.TypeName != string.Empty) defaultXmlType = XmlConvert.EncodeLocalName (atts.XmlType.TypeName); includeInSchema = atts.XmlType.IncludeInSchema; } elementName = defaultXmlType; if (root != null) { if (root.ElementName.Length != 0) elementName = XmlConvert.EncodeLocalName(root.ElementName); if (root.Namespace != null) rootNamespace = root.Namespace; nullable = root.IsNullable; } if (rootNamespace == null) rootNamespace = ""; if (typeNamespace == null) typeNamespace = rootNamespace; XmlTypeMapping map; switch (typeData.SchemaType) { case SchemaTypes.XmlSerializable: map = new XmlSerializableMapping (root, elementName, rootNamespace, typeData, defaultXmlType, typeNamespace); break; case SchemaTypes.Primitive: if (!typeData.IsXsdType) map = new XmlTypeMapping (elementName, rootNamespace, typeData, defaultXmlType, XmlSerializer.WsdlTypesNamespace); else map = new XmlTypeMapping (elementName, rootNamespace, typeData, defaultXmlType, typeNamespace); break; default: map = new XmlTypeMapping (elementName, rootNamespace, typeData, defaultXmlType, typeNamespace); break; } map.IncludeInSchema = includeInSchema; map.IsNullable = nullable; relatedMaps.Add (map); return map; }
/// <include file='doc\XmlSerializerFactory.uex' path='docs/doc[@for="XmlSerializerFactory.CreateSerializer5"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlSerializer CreateSerializer(XmlTypeMapping xmlTypeMapping) { TempAssembly tempAssembly = XmlSerializer.GenerateTempAssembly(xmlTypeMapping); return((XmlSerializer)tempAssembly.Contract.TypedSerializers[xmlTypeMapping.Key]); }
CodeMemberMethod GenerateMethod (CodeIdentifiers memberIds, HttpOperationBinding httpOper, XmlMembersMapping inputMembers, XmlTypeMapping outputMember) { CodeIdentifiers pids = new CodeIdentifiers (); CodeMemberMethod method = new CodeMemberMethod (); CodeMemberMethod methodBegin = new CodeMemberMethod (); CodeMemberMethod methodEnd = new CodeMemberMethod (); method.Attributes = MemberAttributes.Public; methodBegin.Attributes = MemberAttributes.Public; methodEnd.Attributes = MemberAttributes.Public; // Find unique names for temporary variables for (int n=0; n<inputMembers.Count; n++) pids.AddUnique (inputMembers[n].MemberName, inputMembers[n]); string varAsyncResult = pids.AddUnique ("asyncResult","asyncResult"); string varCallback = pids.AddUnique ("callback","callback"); string varAsyncState = pids.AddUnique ("asyncState","asyncState"); string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name),method); method.Name = Operation.Name; methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + Operation.Name),method); methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + Operation.Name),method); method.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.Parameters.Add (new CodeParameterDeclarationExpression (typeof (IAsyncResult),varAsyncResult)); CodeExpression[] paramArray = new CodeExpression [inputMembers.Count]; for (int n=0; n<inputMembers.Count; n++) { string ptype = GetSimpleType (inputMembers[n]); CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (ptype, inputMembers[n].MemberName); param.Direction = FieldDirection.In; method.Parameters.Add (param); methodBegin.Parameters.Add (param); paramArray [n] = new CodeVariableReferenceExpression (param.Name); } bool isVoid = true; if (outputMember != null) { method.ReturnType = new CodeTypeReference (outputMember.TypeFullName); methodEnd.ReturnType = new CodeTypeReference (outputMember.TypeFullName); xmlExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, outputMember, ""); isVoid = false; } methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (AsyncCallback),varCallback)); methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object),varAsyncState)); methodBegin.ReturnType = new CodeTypeReference (typeof(IAsyncResult)); // Array of input parameters CodeArrayCreateExpression methodParams; if (paramArray.Length > 0) methodParams = new CodeArrayCreateExpression (typeof(object), paramArray); else methodParams = new CodeArrayCreateExpression (typeof(object), 0); // Generate method url CodeThisReferenceExpression ethis = new CodeThisReferenceExpression(); CodeExpression thisURlExp = new CodeFieldReferenceExpression (ethis, "Url"); CodePrimitiveExpression metUrl = new CodePrimitiveExpression (httpOper.Location); CodeBinaryOperatorExpression expMethodLocation = new CodeBinaryOperatorExpression (thisURlExp, CodeBinaryOperatorType.Add, metUrl); // Invoke call CodePrimitiveExpression varMsgName = new CodePrimitiveExpression (messageName); CodeMethodInvokeExpression inv; inv = new CodeMethodInvokeExpression (ethis, "Invoke", varMsgName, expMethodLocation, methodParams); if (!isVoid) method.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (method.ReturnType, inv))); else method.Statements.Add (inv); // Begin Invoke Call CodeExpression expCallb = new CodeVariableReferenceExpression (varCallback); CodeExpression expAsyncs = new CodeVariableReferenceExpression (varAsyncState); inv = new CodeMethodInvokeExpression (ethis, "BeginInvoke", varMsgName, expMethodLocation, methodParams, expCallb, expAsyncs); methodBegin.Statements.Add (new CodeMethodReturnStatement (inv)); // End Invoke call CodeExpression varAsyncr = new CodeVariableReferenceExpression (varAsyncResult); inv = new CodeMethodInvokeExpression (ethis, "EndInvoke", varAsyncr); if (!isVoid) methodEnd.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (methodEnd.ReturnType, inv))); else methodEnd.Statements.Add (inv); // Attributes CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.HttpMethodAttribute"); att.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(GetOutMimeFormatter ()))); att.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(GetInMimeFormatter ()))); AddCustomAttribute (method, att, true); CodeTypeDeclaration.Members.Add (method); CodeTypeDeclaration.Members.Add (methodBegin); CodeTypeDeclaration.Members.Add (methodEnd); return method; }
XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form, XmlTypeMapping emap, int order) { XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData); einfo.ElementName = name; einfo.Namespace = ns; einfo.IsNullable = isNillable; einfo.Form = GetForm (form, ns, true); if (typeData.IsComplexType) einfo.MappedType = emap; einfo.ExplicitOrder = order; return einfo; }
string GenerateTypeElement(XmlTypeMapping xmlTypeMapping) { ElementAccessor element = xmlTypeMapping.Accessor; TypeMapping mapping = element.Mapping; string methodName = NextMethodName(element.Name); Writer.WriteLine(); Writer.Write("public object "); Writer.Write(methodName); Writer.WriteLine("() {"); Writer.Indent++; Writer.WriteLine("object o = null;"); MemberMapping member = new MemberMapping(); member.TypeDesc = mapping.TypeDesc; //member.ReadOnly = !mapping.TypeDesc.HasDefaultConstructor; member.Elements = new ElementAccessor[] { element }; Member[] members = new Member[] { new Member(this,"o", "o", "a", 0, member) }; Writer.WriteLine("Reader.MoveToContent();"); string unknownNode = "UnknownNode(null, " + ExpectedElements(members) + ");"; WriteMemberElements(members, "throw CreateUnknownNodeException();", unknownNode, element.Any ? members[0] : null, null, null); if (element.IsSoap) { Writer.WriteLine("Referenced(o);"); Writer.WriteLine("ReadReferencedElements();"); } Writer.WriteLine("return (object)o;"); Writer.Indent--; Writer.WriteLine("}"); return methodName; }
XmlTypeMapping CreateTypeMapping (XmlQualifiedName typeQName, SchemaTypes schemaType, XmlQualifiedName root) { string typeName = CodeIdentifier.MakeValid (typeQName.Name); typeName = typeIdentifiers.AddUnique (typeName, null); TypeData typeData = new TypeData (typeName, typeName, typeName, schemaType, null); string rootElem; string rootNs; if (root != null) { rootElem = root.Name; rootNs = root.Namespace; } else { rootElem = typeQName.Name; rootNs = ""; } XmlTypeMapping map = new XmlTypeMapping (rootElem, rootNs, typeData, typeQName.Name, typeQName.Namespace); map.IncludeInSchema = true; RegisterTypeMapping (typeQName, typeData, map); return map; }
protected override void GenerateClassInclude (CodeAttributeDeclarationCollection attributes, XmlTypeMapping map) { CodeAttributeDeclaration iatt = new CodeAttributeDeclaration ("System.Xml.Serialization.SoapInclude"); iatt.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(map.TypeData.FullTypeName))); attributes.Add (iatt); }
XmlTypeMapping CreateArrayTypeMapping (XmlQualifiedName typeQName, TypeData arrayTypeData) { XmlTypeMapping map; if (encodedFormat) map = new XmlTypeMapping ("Array", XmlSerializer.EncodingNamespace, arrayTypeData, "Array", XmlSerializer.EncodingNamespace); else map = new XmlTypeMapping (arrayTypeData.XmlType, typeQName.Namespace, arrayTypeData, arrayTypeData.XmlType, typeQName.Namespace); map.IncludeInSchema = true; RegisterTypeMapping (typeQName, arrayTypeData, map); return map; }
public void ExportTypeMapping (XmlTypeMapping xmlTypeMapping) { codeGenerator.ExportTypeMapping (xmlTypeMapping); }
TypeData GetElementTypeData (XmlQualifiedName typeQName, XmlSchemaElement elem, XmlQualifiedName root, out XmlTypeMapping map) { bool sharedAnnType = false; map = null; if (!elem.RefName.IsEmpty) { XmlSchemaElement refElem = FindRefElement (elem); if (refElem == null) throw new InvalidOperationException ("Global element not found: " + elem.RefName); root = elem.RefName; elem = refElem; sharedAnnType = true; } TypeData td; if (!elem.SchemaTypeName.IsEmpty) { td = GetTypeData (elem.SchemaTypeName, root, elem.IsNillable); map = GetRegisteredTypeMapping (td); } else if (elem.SchemaType == null) td = TypeTranslator.GetTypeData (typeof(object)); else td = GetTypeData (elem.SchemaType, typeQName, elem.Name, sharedAnnType, root); if (map == null && td.IsComplexType) map = GetTypeMapping (td); return td; }
/// <include file='doc\SoapReflectionImporter.uex' path='docs/doc[@for="XmlReflectionImporter.ImportTypeMapping1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlTypeMapping ImportTypeMapping(Type type, string defaultNamespace) { ElementAccessor element = new ElementAccessor(); element.IsSoap = true; element.Mapping = ImportTypeMapping(modelScope.GetTypeModel(type)); element.Name = element.Mapping.DefaultElementName; element.Namespace = element.Mapping.Namespace == null ? defaultNamespace : element.Mapping.Namespace; element.Form = XmlSchemaForm.Qualified; XmlTypeMapping xmlMapping = new XmlTypeMapping(typeScope, element); xmlMapping.SetKeyInternal(XmlMapping.GenerateKey(type, null, defaultNamespace)); xmlMapping.IsSoap = true; xmlMapping.GenerateSerializer = true; return xmlMapping; }
XmlTypeMapping GetTypeMapping (TypeData typeData) { if (typeData.Type == typeof(object) && !anyTypeImported) ImportAllObjectTypes (); XmlTypeMapping map = GetRegisteredTypeMapping (typeData); if (map != null) return map; if (typeData.IsListType) { // Create an array map for the type XmlTypeMapping itemMap = GetTypeMapping (typeData.ListItemTypeData); map = new XmlTypeMapping (typeData.XmlType, itemMap.Namespace, typeData, typeData.XmlType, itemMap.Namespace); map.IncludeInSchema = true; ListMap listMap = new ListMap (); listMap.ItemInfo = new XmlTypeMapElementInfoList(); listMap.ItemInfo.Add (CreateElementInfo (itemMap.Namespace, null, typeData.ListItemTypeData.XmlType, typeData.ListItemTypeData, false, XmlSchemaForm.None, -1)); map.ObjectMap = listMap; RegisterTypeMapping (new XmlQualifiedName(map.ElementName, map.Namespace), typeData, map); return map; } else if (typeData.SchemaType == SchemaTypes.Primitive || typeData.Type == typeof(object) || typeof(XmlNode).IsAssignableFrom(typeData.Type)) { return CreateSystemMap (typeData); } throw new InvalidOperationException ("Map for type " + typeData.TypeName + " not found"); }
string GenerateTypeElement(XmlTypeMapping xmlTypeMapping) { ElementAccessor element = xmlTypeMapping.Accessor; TypeMapping mapping = element.Mapping; string methodName = NextMethodName(element.Name); Writer.WriteLine(); Writer.Write("public void "); Writer.Write(methodName); Writer.WriteLine("(object o) {"); Writer.Indent++; Writer.WriteLine("WriteStartDocument();"); Writer.WriteLine("if (o == null) {"); Writer.Indent++; if (element.IsNullable){ if(mapping.IsSoap) WriteEncodedNullTag(element.Name, (element.Form == XmlSchemaForm.Qualified ? element.Namespace : "")); else WriteLiteralNullTag(element.Name, (element.Form == XmlSchemaForm.Qualified ? element.Namespace : "")); } else WriteEmptyTag(element.Name, (element.Form == XmlSchemaForm.Qualified ? element.Namespace : "")); Writer.WriteLine("return;"); Writer.Indent--; Writer.WriteLine("}"); if (!mapping.IsSoap && !mapping.TypeDesc.IsValueType && !mapping.TypeDesc.Type.IsPrimitive) { Writer.WriteLine("TopLevelElement();"); } WriteMember("o", null, new ElementAccessor[] { element }, null, null, mapping.TypeDesc, !element.IsSoap); if (mapping.IsSoap) { Writer.WriteLine("WriteReferencedElements();"); } Writer.Indent--; Writer.WriteLine("}"); return methodName; }
void AddObjectDerivedMap (XmlTypeMapping map) { TypeData typeData = TypeTranslator.GetTypeData (typeof(object)); XmlTypeMapping omap = GetRegisteredTypeMapping (typeData); if (omap == null) omap = CreateSystemMap (typeData); omap.DerivedTypes.Add (map); }