ExportTypeMembers()

void System.Xml.Serialization.XmlSchemaExporter.ExportTypeMembers ( XmlSchemaComplexType type, MemberMapping[] members, string name, string ns, bool hasSimpleContent, bool openModel )

inlineprivate

Definition at line 1079 of file XmlSchemaExporter.cs.

    {
        XmlSchemaGroupBase xmlSchemaGroupBase = new XmlSchemaSequence();
        TypeMapping typeMapping = null;
        foreach (MemberMapping memberMapping in members)
        {
            if (memberMapping.Ignore)
            {
                continue;
            }
            if (memberMapping.Text != null)
            {
                if (typeMapping != null)
                {
                    throw new InvalidOperationException(System.SR.Format(System.SR.XmlIllegalMultipleText, name));
                }
                typeMapping = memberMapping.Text.Mapping;
            }
            if (memberMapping.Elements.Length != 0)
            {
                bool repeats = memberMapping.TypeDesc.IsArrayLike && (memberMapping.Elements.Length != 1 || !(memberMapping.Elements[0].Mapping is ArrayMapping));
                bool valueTypeOptional = memberMapping.CheckSpecified != 0 || memberMapping.CheckShouldPersist;
                ExportElementAccessors(xmlSchemaGroupBase, memberMapping.Elements, repeats, valueTypeOptional, ns);
            }
        }
        if (xmlSchemaGroupBase.Items.Count > 0)
        {
            if (type.ContentModel != null)
            {
                if (type.ContentModel.Content is XmlSchemaComplexContentRestriction)
                {
                    ((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Particle = xmlSchemaGroupBase;
                }
                else
                {
                    if (!(type.ContentModel.Content is XmlSchemaComplexContentExtension))
                    {
                        throw new InvalidOperationException(System.SR.Format(System.SR.XmlInvalidContent, type.ContentModel.Content.GetType().Name));
                    }
                    ((XmlSchemaComplexContentExtension)type.ContentModel.Content).Particle = xmlSchemaGroupBase;
                }
            }
            else
            {
                type.Particle = xmlSchemaGroupBase;
            }
        }
        if (typeMapping != null)
        {
            if (hasSimpleContent)
            {
                if (typeMapping is PrimitiveMapping && xmlSchemaGroupBase.Items.Count == 0)
                {
                    PrimitiveMapping primitiveMapping = (PrimitiveMapping)typeMapping;
                    if (primitiveMapping.IsList)
                    {
                        type.IsMixed = true;
                    }
                    else
                    {
                        if (primitiveMapping.IsAnonymousType)
                        {
                            throw new InvalidOperationException(System.SR.Format(System.SR.XmlAnonymousBaseType, typeMapping.TypeDesc.Name, primitiveMapping.TypeDesc.Name, "AnonymousType", "false"));
                        }
                        XmlSchemaSimpleContent xmlSchemaSimpleContent = new XmlSchemaSimpleContent();
                        XmlSchemaSimpleContentExtension xmlSchemaSimpleContentExtension = (XmlSchemaSimpleContentExtension)(xmlSchemaSimpleContent.Content = new XmlSchemaSimpleContentExtension());
                        type.ContentModel = xmlSchemaSimpleContent;
                        xmlSchemaSimpleContentExtension.BaseTypeName = ExportPrimitiveMapping(primitiveMapping, ns);
                    }
                }
            }
            else
            {
                type.IsMixed = true;
            }
        }
        bool flag = false;
        for (int j = 0; j < members.Length; j++)
        {
            AttributeAccessor attribute = members[j].Attribute;
            if (attribute != null)
            {
                ExportAttributeAccessor(type, members[j].Attribute, members[j].CheckSpecified != 0 || members[j].CheckShouldPersist, ns);
                if (members[j].Attribute.Any)
                {
                    flag = true;
                }
            }
        }
        if (openModel && !flag)
        {
            AttributeAccessor attributeAccessor = new AttributeAccessor();
            attributeAccessor.Any = true;
            ExportAttributeAccessor(type, attributeAccessor, valueTypeOptional: false, ns);
        }
    }

References System.Xml.Dictionary, System.Xml.Serialization.XmlSchemaExporter.ExportAttributeAccessor(), System.Xml.Serialization.XmlSchemaExporter.ExportElementAccessors(), System.Xml.Serialization.XmlSchemaExporter.ExportPrimitiveMapping(), System.SR.Format(), System.type, System.SR.XmlAnonymousBaseType, System.SR.XmlIllegalMultipleText, and System.SR.XmlInvalidContent.

Referenced by System.Xml.Serialization.XmlSchemaExporter.ExportMembersMapping(), and System.Xml.Serialization.XmlSchemaExporter.ExportStructMapping().