/// <summary> /// Creates the schema type representing the trigger type /// </summary> /// <returns>Type definition for a trigger</returns> static XmlSchemaType CreateTriggerType() { XmlSchemaComplexContentExtension Extension = new XmlSchemaComplexContentExtension(); Extension.BaseTypeName = GetQualifiedTypeName(ScriptSchemaStandardType.TriggerBody); Extension.Attributes.Add(CreateSchemaAttribute("Name", ScriptSchemaStandardType.QualifiedName, XmlSchemaUse.Required)); Extension.Attributes.Add(CreateSchemaAttribute("If", ScriptSchemaStandardType.BalancedString, XmlSchemaUse.Optional)); XmlSchemaComplexContent ContentModel = new XmlSchemaComplexContent(); ContentModel.Content = Extension; XmlSchemaComplexType ComplexType = new XmlSchemaComplexType(); ComplexType.Name = GetTypeName(ScriptSchemaStandardType.Trigger); ComplexType.ContentModel = ContentModel; return(ComplexType); }
static void WriteComplexType(this SimpleClassFormatter formatter, XmlSchemaComplexType type, String name, CommandLineOptions options, Queue <XmlSchema> schemas, HashSet <XmlSchema> processedSchemas) { String baseType = null; XmlSchemaComplexContentExtension extension = type.ContentModel?.Content as XmlSchemaComplexContentExtension; // Check if we've a extension if (extension != null) { // Set base type baseType = extension.BaseTypeName.Name.CleanName(options.CleanNames); // Add schema for processing XmlSchema schema = LoadedSchemas.Schemas().Cast <XmlSchema>().FirstOrDefault(p => p.SchemaTypes.Contains(extension.BaseTypeName)); if (schema != null && processedSchemas.Add(schema)) { schemas.Enqueue(schema); } } // Open class definition if (options.DataContracts) { if (name == null) { formatter.WriteAttribute(typeof(DataContractAttribute), new KeyValuePair <String, String>("Namespace", $"\"{GetSchema(type).TargetNamespace}\"")); } else { formatter.WriteAttribute(typeof(DataContractAttribute), new KeyValuePair <String, String>("Name", $"\"{name}\""), new KeyValuePair <String, String>("Namespace", $"\"{GetSchema(type).TargetNamespace}\"")); } } formatter.BeginClass((name ?? type.Name).CleanName(options.CleanNames), baseType, isAbstract: type.IsAbstract); if ((type.Particle ?? extension.Particle) is XmlSchemaGroupBase sequence) { formatter.WriteSequence(sequence, options, schemas, processedSchemas); } else if (type.Particle != null) { throw new NotImplementedException(); } // Close class definition formatter.CloseBracket(); }
void WriteComplexContent(XmlTextWriter xtw, string ns, XmlSchemaComplexContent content) { XmlQualifiedName qname; XmlSchemaComplexContentExtension ext = content.Content as XmlSchemaComplexContentExtension; if (ext != null) { qname = ext.BaseTypeName; } else { XmlSchemaComplexContentRestriction rest = (XmlSchemaComplexContentRestriction)content.Content; qname = rest.BaseTypeName; if (qname == arrayType) { ParseArrayType(rest, out qname); XmlSchemaElement elem = new XmlSchemaElement(); elem.Name = "Item"; elem.SchemaTypeName = qname; xtw.WriteAttributeString("arrayType", SoapEncodingNamespace, qname.Name + "[2]"); WriteContentItem(xtw, ns, elem, true); return; } } // Add base map members to this map XmlSchemaComplexType ctype = FindComplexTyype(qname); WriteComplexTypeAttributes(xtw, ctype); if (ext != null) { // Add the members of this map WriteAttributes(xtw, ext.Attributes, ext.AnyAttribute); if (ext.Particle != null) { WriteParticleComplexContent(xtw, ns, ext.Particle); } } WriteComplexTypeElements(xtw, ns, ctype); }
/// <summary> /// Gets the extension signature. /// </summary> /// <param name="extension">The extension.</param> /// <param name="name">The name.</param> /// <returns></returns> private string GetExtensionSignature(XmlSchemaComplexContentExtension extension, XmlQualifiedName name) { var particle = (XmlSchemaSequence)extension.Particle; var fields = particle.Items .OfType <XmlSchemaElement>() .Select(GetNativeElement); return(GetHashFor( writer => { writer.Write(GetTypeName(name)); writer.Write(GetTypeName(extension.BaseTypeName)); foreach (var field in fields) { writer.Write(field.Name); writer.Write(field.Type.FullName); } })); }
private void LoadXmlSchemaComplexType(XmlSchemaComplexType ctype) { if (ctype == null) { return; } LoadXmlSchemaObjectCollection(ctype.Attributes); XmlSchemaComplexContent content = ctype.ContentModel as XmlSchemaComplexContent; if (content != null) { XmlSchemaComplexContentExtension cext = content.Content as XmlSchemaComplexContentExtension; if (cext != null) { LoadXmlSchemaObjectCollection(cext.Attributes); if (cext.BaseTypeName != null) { string typeName = cext.BaseTypeName.Name; if (xcontoler._complexTypes.ContainsKey(typeName)) { LoadXmlSchemaComplexType(xcontoler._complexTypes[typeName]); } } LoadXmlSchemaObject(cext.Particle); } } else { XmlSchemaSimpleContent scontent = ctype.ContentModel as XmlSchemaSimpleContent; if (scontent != null) { XmlSchemaSimpleContentExtension sext = scontent.Content as XmlSchemaSimpleContentExtension; if (sext != null) { LoadXmlSchemaObjectCollection(sext.Attributes); } } else { LoadXmlSchemaObject(ctype.Particle); } } }
private void GenerateComplexType(XmlSchema schema, IXmlTypeSerialiser serialiser) { XmlSchemaComplexType complexType = new XmlSchemaComplexType(); complexType.Name = GenerateItemName(serialiser.Type); var particle = GenerateSchemaElementsForMembers(serialiser); if (serialiser.Attribute.Extends != null) { var extension = new XmlSchemaComplexContentExtension { BaseTypeName = new XmlQualifiedName(GenerateItemName(serialiser.Attribute.Extends), NamespaceUri), Particle = particle }; complexType.ContentModel = new XmlSchemaComplexContent { Content = extension }; if (!baseTypes.Contains(serialiser.Attribute.Extends)) { baseTypes.Add(serialiser.Attribute.Extends); } } else { complexType.Particle = particle; } schema.Items.Add(complexType); if (baseTypes.Contains(serialiser.Type)) { baseTypes.Remove(serialiser.Type); } loadedTypes.Add(serialiser.Type, new ReferencedType { Extends = serialiser.Attribute.Extends, NamespaceUri = NamespaceUri, TypeName = complexType.Name, ElementName = serialiser.Attribute.Name, Description = serialiser.Attribute.Description }); }
public Rating() { baseSchema = new XmlSchema(); //<xs:complexType name="RatingN"> first time is empty XmlSchemaComplexType newType = new XmlSchemaComplexType(); newType.Name = ""; baseSchema.Items.Add(newType); //<xs:complexContent> XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent(); newType.ContentModel = complexContent; //<xs:extension base="Rating"> XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension(); complexContent.Content = complexContentExtension; complexContentExtension.BaseTypeName = new XmlQualifiedName("Rating"); //<xs:sequence> XmlSchemaSequence seq = new XmlSchemaSequence(); complexContentExtension.Particle = seq; //<xs:element name="Value" type="xs:integer"/> XmlSchemaElement elem = new XmlSchemaElement(); seq.Items.Add(elem); elem.Name = "Value"; elem.SchemaTypeName = new XmlQualifiedName("integer", "http://www.w3.org/2001/XMLSchema"); //to Check XmlSchemaMinInclusiveFacet minFacet = new XmlSchemaMinInclusiveFacet(); minFacet.Value = "0"; Common.addFacet(minFacet, Common.getElementFromSchema(baseSchema)); maxRateFacet.Value = "5"; Common.addFacet(maxRateFacet, Common.getElementFromSchema(baseSchema)); }
XObject[] CreateProtoComplexType(XmlSchemaComplexType complexType) { if (complexType.ContentModel != null) { if ((complexType.ContentModel as XmlSchemaSimpleContent) != null) { return(CreateProtoSimpleContent((complexType.ContentModel as XmlSchemaSimpleContent), complexType.BaseXmlSchemaType).ToArray()); } else if ((complexType.ContentModel as XmlSchemaComplexContent) != null) { return(CreateProtoComplexContent((complexType.ContentModel as XmlSchemaComplexContent), complexType.BaseXmlSchemaType).ToArray()); } else { throw new Exception("not implemented"); } } else { var complexContentExt = new XmlSchemaComplexContentExtension(); if (complexType.BaseXmlSchemaType != null) { complexContentExt.BaseTypeName = complexType.BaseXmlSchemaType.QualifiedName; } else { complexContentExt.BaseTypeName = null; } if (complexType.Attributes != null) { foreach (var i in complexType.Attributes) { complexContentExt.Attributes.Add(i); } } complexContentExt.Particle = complexType.Particle; var complexContent = new XmlSchemaComplexContent(); complexContent.Content = complexContentExt; return(CreateProtoComplexContent(complexContent, complexType.BaseXmlSchemaType).ToArray()); } }
internal void ExportStandardComplexType(DataContractAttribute attr, SerializationMap map, List <DataMemberInfo> members) { Type type = map.RuntimeType; var qname = map.XmlName; var ct = CreateComplexType(qname, type); if (type.BaseType != null && type.BaseType != typeof(object)) { ExportCore(type.BaseType, false); var xcc = new XmlSchemaComplexContent(); ct.ContentModel = xcc; var xcce = new XmlSchemaComplexContentExtension(); xcc.Content = xcce; xcce.BaseTypeName = GetSchemaTypeName(type.BaseType); xcce.Particle = CreateMembersSequence(type, members, attr != null); } else { ct.Particle = CreateMembersSequence(type, members, attr != null); } }
/// <summary> /// Creates an element representing a conditional "Do" block, which recursively contains another type /// </summary> /// <param name="InnerType">The base type for the do block to contain</param> /// <returns>New schema element for the block</returns> static XmlSchemaElement CreateDoElement(ScriptSchemaStandardType InnerType) { XmlSchemaComplexContentExtension Extension = new XmlSchemaComplexContentExtension(); Extension.BaseTypeName = GetQualifiedTypeName(InnerType); Extension.Attributes.Add(CreateSchemaAttribute("If", ScriptSchemaStandardType.BalancedString, XmlSchemaUse.Optional)); XmlSchemaComplexContent ContentModel = new XmlSchemaComplexContent(); ContentModel.Content = Extension; XmlSchemaComplexType SchemaType = new XmlSchemaComplexType(); SchemaType.ContentModel = ContentModel; XmlSchemaElement Element = new XmlSchemaElement(); Element.Name = "Do"; Element.SchemaType = SchemaType; return(Element); }
internal static XmlSchemaComplexType GetBaseType(this XmlSchemaComplexContentExtension extension) { var schema = extension.GetSchema(); for (var i = 0; i < schema.Items.Count; i++) { var item = schema.Items[i]; if (item is XmlSchemaComplexType == false) { continue; } var complexType = item as XmlSchemaComplexType; if (complexType.QualifiedName == extension.BaseTypeName) { return(complexType); } } return(null); }
/// <summary> /// Initializes a new instance of the <see cref="VEMap"/> class. /// </summary> public VEMap() { baseSchema = new XmlSchema(); //<xs:complexType name="VEMapN"> XmlSchemaComplexType newType = new XmlSchemaComplexType(); newType.Name = ""; baseSchema.Items.Add(newType); //<xs:complexContent> XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent(); newType.ContentModel = complexContent; //<xs:extension base="VEMap"> XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension(); complexContent.Content = complexContentExtension; complexContentExtension.BaseTypeName = new XmlQualifiedName("VEMap"); //<xs:sequence> XmlSchemaSequence seq = new XmlSchemaSequence(); complexContentExtension.Particle = seq; //<xs:element name="Latitude" type="xs:string"/> XmlSchemaElement elem1 = new XmlSchemaElement(); seq.Items.Add(elem1); elem1.Name = "Latitude"; elem1.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); //<xs:element name="Longitude" type="xs:string"/> XmlSchemaElement elem2 = new XmlSchemaElement(); seq.Items.Add(elem2); elem2.Name = "Longitude"; elem2.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); }
/// <summary> /// Creates a field instance from his XML schema representation, taking the field structure from a schema and the constraints from another. /// </summary> /// <param name="schema"> /// A <see cref="XmlSchemaSet"/> which contains the whole form to render /// </param> /// <param name="elm"> /// A <see cref="XmlSchemaElement"/> which contains the definition of the field to instantiate /// </param> /// <returns> /// A <see cref="Field"/> built following the schemas above /// </returns> public static IField GetInstance(XmlSchemaSet schema, XmlSchemaObject scobj) { if (scobj is XmlSchemaElement && !((XmlSchemaElement)scobj).SchemaTypeName.IsEmpty) { XmlSchemaElement elm = (XmlSchemaElement)scobj; try { foreach (XmlSchema xsd in schema.Schemas()) { string searchname = elm.SchemaTypeName.ToString(); //controlla se nello schema è presente l'elemento cercato if (xsd.SchemaTypes.Contains(new XmlQualifiedName(searchname))) { foreach (XmlSchemaObject obj in xsd.Items) { if (obj is XmlSchemaComplexType && ((XmlSchemaComplexType)obj).Name.ToString() == searchname) { XmlSchema fieldschema = new XmlSchema(); fieldschema.Items.Add(obj); XmlSchemaComplexContent xcc = (XmlSchemaComplexContent)((XmlSchemaComplexType)obj).ContentModel; XmlSchemaComplexContentExtension xext = (XmlSchemaComplexContentExtension)xcc.Content; Type tipo = Type.GetType("Fields." + xext.BaseTypeName.ToString(), true); Type[] par = { fieldschema.GetType(), typeof(string) }; //elm.Name prende il nome dell'elemento contenuto in elm Object[] vals = { fieldschema, elm.Name }; return((IField)tipo.GetConstructor(par).Invoke(vals)); } } } } } catch (Exception) { return(null); } return(null); } return(null); }
private XmlQualifiedName ExportStructMapping(StructMapping mapping, string ns) { if (mapping.TypeDesc.IsRoot) { return(this.ExportRootMapping(mapping)); } XmlSchemaComplexType type = (XmlSchemaComplexType)this.types[mapping]; if (type == null) { if (!mapping.IncludeInSchema) { throw new InvalidOperationException(Res.GetString("XmlSoapCannotIncludeInSchema", new object[] { mapping.TypeDesc.Name })); } this.CheckForDuplicateType(mapping.TypeName, mapping.Namespace); type = new XmlSchemaComplexType { Name = mapping.TypeName }; this.types.Add(mapping, type); this.AddSchemaItem(type, mapping.Namespace, ns); type.IsAbstract = mapping.TypeDesc.IsAbstract; if ((mapping.BaseMapping != null) && mapping.BaseMapping.IncludeInSchema) { XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension { BaseTypeName = this.ExportStructMapping(mapping.BaseMapping, mapping.Namespace) }; XmlSchemaComplexContent content = new XmlSchemaComplexContent { Content = extension }; type.ContentModel = content; } this.ExportTypeMembers(type, mapping.Members, mapping.Namespace); this.ExportDerivedMappings(mapping); } else { this.AddSchemaImport(mapping.Namespace, ns); } return(new XmlQualifiedName(type.Name, mapping.Namespace)); }
/// <summary> /// Finds the named child element contained in the extension element. /// </summary> XmlSchemaElement FindChildElement(XmlSchemaComplexContentExtension extension, QualifiedName name) { var complexType = FindNamedType(schema, extension.BaseTypeName); if (complexType == null) { return(null); } var matchedElement = FindChildElement(complexType, name); if (matchedElement != null) { return(matchedElement); } var sequence = extension.Particle as XmlSchemaSequence; if (sequence != null) { return(FindElement(sequence.Items, name)); } var choice = extension.Particle as XmlSchemaChoice; if (choice != null) { return(FindElement(choice.Items, name)); } var groupRef = extension.Particle as XmlSchemaGroupRef; if (groupRef != null) { return(FindElement(groupRef, name)); } return(null); }
public CheckBoxField(XmlSchema schema, string name) { // in this constructor it's useful to set the ID, cause GUI is calling it this.Name = name; //why don't use the former constructor? <--- baseSchema = new XmlSchema(); //<xs:complexType name="CheckBoxN"> XmlSchemaComplexType newType = new XmlSchemaComplexType(); newType.Name = ((XmlSchemaComplexType)schema.Items[0]).Name; baseSchema.Items.Add(newType); //<xs:complexContent> XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent(); newType.ContentModel = complexContent; //<xs:extension base="CheckBox"> XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension(); complexContent.Content = complexContentExtension; complexContentExtension.BaseTypeName = new XmlQualifiedName("CheckBox"); //<xs:sequence> XmlSchemaSequence seq = new XmlSchemaSequence(); complexContentExtension.Particle = seq; //<xs:element name="Value" type="xs:boolean" default="false"/> XmlSchemaElement elem = new XmlSchemaElement(); seq.Items.Add(elem); elem.Name = "Value"; elem.SchemaTypeName = new XmlQualifiedName("boolean", "http://www.w3.org/2001/XMLSchema"); elem.DefaultValue = "false"; }
XmlQualifiedName ExportStructMapping(StructMapping mapping, string ns) { if (mapping.TypeDesc.IsRoot) { return(ExportRootMapping(mapping)); } XmlSchemaComplexType type = (XmlSchemaComplexType)types[mapping]; if (type == null) { if (!mapping.IncludeInSchema) { throw new InvalidOperationException(Res.GetString(Res.XmlSoapCannotIncludeInSchema, mapping.TypeDesc.Name)); } CheckForDuplicateType(mapping.TypeName, mapping.Namespace); type = new XmlSchemaComplexType(); type.Name = mapping.TypeName; types.Add(mapping, type); AddSchemaItem(type, mapping.Namespace, ns); type.IsAbstract = mapping.TypeDesc.IsAbstract; if (mapping.BaseMapping != null && mapping.BaseMapping.IncludeInSchema) { XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension(); extension.BaseTypeName = ExportStructMapping(mapping.BaseMapping, mapping.Namespace); XmlSchemaComplexContent model = new XmlSchemaComplexContent(); model.Content = extension; type.ContentModel = model; } ExportTypeMembers(type, mapping.Members, mapping.Namespace); ExportDerivedMappings(mapping); } else { AddSchemaImport(mapping.Namespace, ns); } return(new XmlQualifiedName(type.Name, mapping.Namespace)); }
/// <summary> /// Creates the schema type representing the node type /// </summary> /// <returns>Type definition for a node</returns> static XmlSchemaType CreateNodeType() { XmlSchemaComplexContentExtension Extension = new XmlSchemaComplexContentExtension(); Extension.BaseTypeName = GetQualifiedTypeName(ScriptSchemaStandardType.NodeBody); Extension.Attributes.Add(CreateSchemaAttribute("Name", ScriptSchemaStandardType.Name, XmlSchemaUse.Required)); Extension.Attributes.Add(CreateSchemaAttribute("Requires", ScriptSchemaStandardType.NameOrTagList, XmlSchemaUse.Optional)); Extension.Attributes.Add(CreateSchemaAttribute("Produces", ScriptSchemaStandardType.TagList, XmlSchemaUse.Optional)); Extension.Attributes.Add(CreateSchemaAttribute("After", ScriptSchemaStandardType.NameOrTagList, XmlSchemaUse.Optional)); Extension.Attributes.Add(CreateSchemaAttribute("Token", ScriptSchemaStandardType.BalancedString, XmlSchemaUse.Optional)); Extension.Attributes.Add(CreateSchemaAttribute("If", ScriptSchemaStandardType.BalancedString, XmlSchemaUse.Optional)); Extension.Attributes.Add(CreateSchemaAttribute("NotifyOnWarnings", ScriptSchemaStandardType.Boolean, XmlSchemaUse.Optional)); XmlSchemaComplexContent ContentModel = new XmlSchemaComplexContent(); ContentModel.Content = Extension; XmlSchemaComplexType ComplexType = new XmlSchemaComplexType(); ComplexType.Name = GetTypeName(ScriptSchemaStandardType.Node); ComplexType.ContentModel = ContentModel; return(ComplexType); }
public static IEnumerable <XmlSchemaAttribute> XsdAttributesInScope(this XmlSchemaType ty) { if (ty != null) { XmlSchemaComplexType xmlSchemaComplexType = ty as XmlSchemaComplexType; if (xmlSchemaComplexType != null) { foreach (XmlSchemaAttribute attribute in xmlSchemaComplexType.Attributes) { yield return(attribute); } if (xmlSchemaComplexType.ContentModel != null) { XmlSchemaComplexContent contentModel = xmlSchemaComplexType.ContentModel as XmlSchemaComplexContent; if (contentModel != null) { XmlSchemaComplexContentExtension content = contentModel.Content as XmlSchemaComplexContentExtension; if (content == null) { goto Label0; } foreach (XmlSchemaAttribute xmlSchemaAttribute in content.Attributes) { yield return(xmlSchemaAttribute); } } else { goto Label0; } } } } Label0: yield break; goto Label0; }
private const int MAX_ELEM_BEFORE_DROPDOWN = 10; //very great Name #region constructors public RadioButtonList() { baseSchema = new XmlSchema(); XmlSchemaComplexType ctype = new XmlSchemaComplexType(); ctype.Name = ""; baseSchema.Items.Add(ctype); XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent(); XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension(); complexContentExtension.BaseTypeName = new XmlQualifiedName("RadioButtonList"); ctype.ContentModel = complexContent; complexContent.Content = complexContentExtension; XmlSchemaSequence seq = new XmlSchemaSequence(); complexContentExtension.Particle = seq; XmlSchemaElement elem = new XmlSchemaElement(); elem.Name = "Value"; seq.Items.Add(elem); XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); elem.SchemaType = simpleType; simpleType.Content = restriction; //for direct access elemPointer = elem; }
void GetChildElementCompletionData(XmlCompletionDataList data, XmlSchemaComplexContentExtension extension, string prefix) { var complexType = FindNamedType(schema, extension.BaseTypeName); if (complexType != null) { GetChildElementCompletionData(data, complexType, prefix); } if (extension.Particle == null) { return; } var sequence = extension.Particle as XmlSchemaSequence; if (sequence != null) { GetChildElementCompletionData(data, sequence.Items, prefix); return; } var choice = extension.Particle as XmlSchemaChoice; if (choice != null) { GetChildElementCompletionData(data, choice.Items, prefix); return; } var groupRef = extension.Particle as XmlSchemaGroupRef; if (groupRef != null) { GetChildElementCompletionData(data, groupRef, prefix); return; } }
public static void Main() { XmlSchema schema = new XmlSchema(); // <xs:complexType name="address"> XmlSchemaComplexType address = new XmlSchemaComplexType(); schema.Items.Add(address); address.Name = "address"; // <xs:sequence> XmlSchemaSequence sequence = new XmlSchemaSequence(); address.Particle = sequence; // <xs:element name="name" type="xs:string"/> XmlSchemaElement elementName = new XmlSchemaElement(); sequence.Items.Add(elementName); elementName.Name = "name"; elementName.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // <xs:element name="street" type="xs:string"/> XmlSchemaElement elementStreet = new XmlSchemaElement(); sequence.Items.Add(elementStreet); elementStreet.Name = "street"; elementStreet.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // <xs:element name="city" type="xs:string"/> XmlSchemaElement elementCity = new XmlSchemaElement(); sequence.Items.Add(elementCity); elementCity.Name = "city"; elementCity.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // <xs:complexType name="USAddress"> XmlSchemaComplexType USAddress = new XmlSchemaComplexType(); schema.Items.Add(USAddress); USAddress.Name = "USAddress"; // <xs:complexContent> XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent(); USAddress.ContentModel = complexContent; // <xs:extension base="address"> XmlSchemaComplexContentExtension extensionAddress = new XmlSchemaComplexContentExtension(); complexContent.Content = extensionAddress; extensionAddress.BaseTypeName = new XmlQualifiedName("address"); // <xs:sequence> XmlSchemaSequence sequence2 = new XmlSchemaSequence(); extensionAddress.Particle = sequence2; // <xs:element name="state" type="xs:string"/> XmlSchemaElement elementUSState = new XmlSchemaElement(); sequence2.Items.Add(elementUSState); elementUSState.Name = "state"; elementUSState.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // <xs:element name="zipcode" type="xs:positiveInteger"/> XmlSchemaElement elementZipcode = new XmlSchemaElement(); sequence2.Items.Add(elementZipcode); elementZipcode.Name = "zipcode"; elementZipcode.SchemaTypeName = new XmlQualifiedName("positiveInteger", "http://www.w3.org/2001/XMLSchema"); XmlSchemaSet schemaSet = new XmlSchemaSet(); schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne); schemaSet.Add(schema); schemaSet.Compile(); XmlSchema compiledSchema = null; foreach (XmlSchema schema1 in schemaSet.Schemas()) { compiledSchema = schema1; } XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable()); nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema"); compiledSchema.Write(Console.Out, nsmgr); }
private void ExportClassDataContract(ClassDataContract classDataContract, XmlSchema schema) { XmlSchemaComplexType type = new XmlSchemaComplexType(); type.Name = classDataContract.StableName.Name; schema.Items.Add(type); XmlElement genericInfoElement = null; if (classDataContract.UnderlyingType.IsGenericType) { genericInfoElement = ExportGenericInfo(classDataContract.UnderlyingType, Globals.GenericTypeLocalName, Globals.SerializationNamespace); } XmlSchemaSequence rootSequence = new XmlSchemaSequence(); for (int i = 0; i < classDataContract.Members.Count; i++) { DataMember dataMember = classDataContract.Members[i]; XmlSchemaElement element = new XmlSchemaElement(); element.Name = dataMember.Name; XmlElement actualTypeElement = null; DataContract memberTypeContract = _dataContractSet.GetMemberTypeDataContract(dataMember); if (CheckIfMemberHasConflict(dataMember)) { element.SchemaTypeName = AnytypeQualifiedName; actualTypeElement = ExportActualType(memberTypeContract.StableName); SchemaHelper.AddSchemaImport(memberTypeContract.StableName.Namespace, schema); } else { SetElementType(element, memberTypeContract, schema); } SchemaHelper.AddElementForm(element, schema); if (dataMember.IsNullable) { element.IsNillable = true; } if (!dataMember.IsRequired) { element.MinOccurs = 0; } element.Annotation = GetSchemaAnnotation(actualTypeElement, ExportSurrogateData(dataMember), ExportEmitDefaultValue(dataMember)); rootSequence.Items.Add(element); } XmlElement isValueTypeElement = null; if (classDataContract.BaseContract != null) { XmlSchemaComplexContentExtension extension = CreateTypeContent(type, classDataContract.BaseContract.StableName, schema); extension.Particle = rootSequence; if (classDataContract.IsReference && !classDataContract.BaseContract.IsReference) { AddReferenceAttributes(extension.Attributes, schema); } } else { type.Particle = rootSequence; if (classDataContract.IsValueType) { isValueTypeElement = GetAnnotationMarkup(IsValueTypeName, XmlConvert.ToString(classDataContract.IsValueType), schema); } if (classDataContract.IsReference) { AddReferenceAttributes(type.Attributes, schema); } } type.Annotation = GetSchemaAnnotation(genericInfoElement, ExportSurrogateData(classDataContract), isValueTypeElement); }
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); } } }
public bool ContainsColumn(XmlSchemaComplexType xmlSchemaComplexType, XmlSchemaObject columnObject) { XmlQualifiedName columnName = columnObject is XmlSchemaAttribute ? (columnObject as XmlSchemaAttribute).QualifiedName : columnObject is XmlSchemaElement ? (columnObject as XmlSchemaElement).QualifiedName : XmlQualifiedName.Empty; // Columns can be specified as attributes. foreach (XmlSchemaAttribute xmlSchemaAttribute in xmlSchemaComplexType.Attributes) { if (xmlSchemaAttribute.QualifiedName == columnName) { return(true); } } // Comlex content extends a base class. The ComplexContent is mutually exclusive of the Particle, so if the // particle is empty, the ComplexContent is present and should be parsed for columns. if (xmlSchemaComplexType.Particle == null) { // The Comlex Content describes an extension of a base class. if (xmlSchemaComplexType.ContentModel is XmlSchemaComplexContent) { // Strongly type the XmlSchemaContent. XmlSchemaComplexContent xmlSchemaComplexContent = xmlSchemaComplexType.ContentModel as XmlSchemaComplexContent; // A complex content can be derived by extension (adding columns) or restriction (removing columns). This // section will look for the extensions to the base class. if (xmlSchemaComplexContent.Content is XmlSchemaComplexContentExtension) { // The Complex Content Extension describes a base class and the additional columns that make up a // derived class. This section will recursively collect the columns from the base class and then parse // out the extra columns in-line. XmlSchemaComplexContentExtension xmlSchemaComplexContentExtension = xmlSchemaComplexContent.Content as XmlSchemaComplexContentExtension; // The additional columns for this inherited table are found on the <Sequence> node that follows the // <Extension> node. if (xmlSchemaComplexContentExtension.Particle is XmlSchemaSequence) { // Strongly type the XmlSchemaSequence XmlSchemaSequence xmlSchemaSequence = xmlSchemaComplexContentExtension.Particle as XmlSchemaSequence; // Read through the sequence and replace any column from an inherited class with the column in the // derived class. Also note that the columns are added in alphabetical order to give some amount of // predictability to the way the parameter lists are constructed when there are several layers of // inheritance. foreach (XmlSchemaObject xmlSchemaObject in xmlSchemaSequence.Items) { if ((xmlSchemaObject as XmlSchemaElement).QualifiedName == columnName) { return(true); } } } // The Complex Content can also contain attributes that describe columns. foreach (XmlSchemaAttribute xmlSchemaAttribute in xmlSchemaComplexContentExtension.Attributes) { if (xmlSchemaAttribute.QualifiedName == columnName) { return(true); } } } } } else { // This section will parse the simple particle. The particle has no inheritiance to evaluate. if (xmlSchemaComplexType.Particle is XmlSchemaSequence) { // Strongly type the XmlSchemaSequence member. XmlSchemaSequence xmlSchemaSequence = xmlSchemaComplexType.Particle as XmlSchemaSequence; // Each XmlSchemaElement on the Particle describes a column. foreach (XmlSchemaObject xmlSchemaObject in xmlSchemaSequence.Items) { if ((xmlSchemaObject as XmlSchemaElement).QualifiedName == columnName) { return(true); } } } // The ComplexType can also have attributes that describe table columns. foreach (XmlSchemaAttribute xmlSchemaAttribute in xmlSchemaComplexType.Attributes) { if (xmlSchemaAttribute.QualifiedName == columnName) { return(true); } } } return(false); }
static void Check(ConformanceCheckContext ctx, ConformanceChecker checker, Hashtable visitedObjects, XmlSchemaObject value) { if (value == null) { return; } if (visitedObjects.Contains(value)) { return; } visitedObjects.Add(value, value); if (value is XmlSchemaImport) { XmlSchemaImport so = (XmlSchemaImport)value; checker.Check(ctx, so); } else if (value is XmlSchemaAll) { XmlSchemaAll so = (XmlSchemaAll)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Items); } else if (value is XmlSchemaAnnotation) { XmlSchemaAnnotation so = (XmlSchemaAnnotation)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Items); } else if (value is XmlSchemaAttribute) { XmlSchemaAttribute so = (XmlSchemaAttribute)value; checker.Check(ctx, so); } else if (value is XmlSchemaAttributeGroup) { XmlSchemaAttributeGroup so = (XmlSchemaAttributeGroup)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Attributes); Check(ctx, checker, visitedObjects, so.AnyAttribute); Check(ctx, checker, visitedObjects, so.RedefinedAttributeGroup); } else if (value is XmlSchemaAttributeGroupRef) { XmlSchemaAttributeGroupRef so = (XmlSchemaAttributeGroupRef)value; checker.Check(ctx, so); } else if (value is XmlSchemaChoice) { XmlSchemaChoice so = (XmlSchemaChoice)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Items); } else if (value is XmlSchemaComplexContent) { XmlSchemaComplexContent so = (XmlSchemaComplexContent)value; checker.Check(ctx, so); Check(ctx, checker, visitedObjects, so.Content); } else if (value is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension so = (XmlSchemaComplexContentExtension)value; checker.Check(ctx, so); Check(ctx, checker, visitedObjects, so.Particle); CheckObjects(ctx, checker, visitedObjects, so.Attributes); Check(ctx, checker, visitedObjects, so.AnyAttribute); } else if (value is XmlSchemaComplexContentRestriction) { XmlSchemaComplexContentRestriction so = (XmlSchemaComplexContentRestriction)value; checker.Check(ctx, so); Check(ctx, checker, visitedObjects, so.Particle); CheckObjects(ctx, checker, visitedObjects, so.Attributes); Check(ctx, checker, visitedObjects, so.AnyAttribute); } else if (value is XmlSchemaComplexType) { XmlSchemaComplexType so = (XmlSchemaComplexType)value; checker.Check(ctx, so); Check(ctx, checker, visitedObjects, so.ContentModel); Check(ctx, checker, visitedObjects, so.Particle); CheckObjects(ctx, checker, visitedObjects, so.Attributes); Check(ctx, checker, visitedObjects, so.AnyAttribute); Check(ctx, checker, visitedObjects, so.ContentTypeParticle); Check(ctx, checker, visitedObjects, so.AttributeWildcard); } else if (value is XmlSchemaElement) { XmlSchemaElement so = (XmlSchemaElement)value; checker.Check(ctx, so); Check(ctx, checker, visitedObjects, so.SchemaType); CheckObjects(ctx, checker, visitedObjects, so.Constraints); } else if (value is XmlSchemaGroup) { XmlSchemaGroup so = (XmlSchemaGroup)value; checker.Check(ctx, so); Check(ctx, checker, visitedObjects, so.Particle); } else if (value is XmlSchemaGroupRef) { XmlSchemaGroupRef so = (XmlSchemaGroupRef)value; checker.Check(ctx, so); } else if (value is XmlSchemaIdentityConstraint) { XmlSchemaIdentityConstraint so = (XmlSchemaIdentityConstraint)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Fields); Check(ctx, checker, visitedObjects, so.Selector); } else if (value is XmlSchemaKeyref) { XmlSchemaKeyref so = (XmlSchemaKeyref)value; checker.Check(ctx, so); } else if (value is XmlSchemaRedefine) { XmlSchemaRedefine so = (XmlSchemaRedefine)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Items); } else if (value is XmlSchemaSequence) { XmlSchemaSequence so = (XmlSchemaSequence)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Items); } else if (value is XmlSchemaSimpleContent) { XmlSchemaSimpleContent so = (XmlSchemaSimpleContent)value; checker.Check(ctx, so); Check(ctx, checker, visitedObjects, so.Content); } else if (value is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension so = (XmlSchemaSimpleContentExtension)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Attributes); Check(ctx, checker, visitedObjects, so.AnyAttribute); } else if (value is XmlSchemaSimpleContentRestriction) { XmlSchemaSimpleContentRestriction so = (XmlSchemaSimpleContentRestriction)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Attributes); Check(ctx, checker, visitedObjects, so.AnyAttribute); CheckObjects(ctx, checker, visitedObjects, so.Facets); } else if (value is XmlSchemaSimpleType) { XmlSchemaSimpleType so = (XmlSchemaSimpleType)value; checker.Check(ctx, so); Check(ctx, checker, visitedObjects, so.Content); } else if (value is XmlSchemaSimpleTypeList) { XmlSchemaSimpleTypeList so = (XmlSchemaSimpleTypeList)value; checker.Check(ctx, so); } else if (value is XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction so = (XmlSchemaSimpleTypeRestriction)value; checker.Check(ctx, so); CheckObjects(ctx, checker, visitedObjects, so.Facets); } else if (value is XmlSchemaSimpleTypeUnion) { XmlSchemaSimpleTypeUnion so = (XmlSchemaSimpleTypeUnion)value; checker.Check(ctx, so); } }
internal void Depends(XmlSchemaObject item, ArrayList refs) { if (item == null || scope[item] != null) { return; } Type t = item.GetType(); if (typeof(XmlSchemaType).IsAssignableFrom(t)) { XmlQualifiedName baseName = XmlQualifiedName.Empty; XmlSchemaType baseType = null; XmlSchemaParticle particle = null; XmlSchemaObjectCollection attributes = null; if (item is XmlSchemaComplexType) { XmlSchemaComplexType ct = (XmlSchemaComplexType)item; if (ct.ContentModel != null) { XmlSchemaContent content = ct.ContentModel.Content; if (content is XmlSchemaComplexContentRestriction) { baseName = ((XmlSchemaComplexContentRestriction)content).BaseTypeName; attributes = ((XmlSchemaComplexContentRestriction)content).Attributes; } else if (content is XmlSchemaSimpleContentRestriction) { XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction)content; if (restriction.BaseType != null) { baseType = restriction.BaseType; } else { baseName = restriction.BaseTypeName; } attributes = restriction.Attributes; } else if (content is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content; attributes = extension.Attributes; particle = extension.Particle; baseName = extension.BaseTypeName; } else if (content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension extension = (XmlSchemaSimpleContentExtension)content; attributes = extension.Attributes; baseName = extension.BaseTypeName; } } else { attributes = ct.Attributes; particle = ct.Particle; } if (particle is XmlSchemaGroupRef) { XmlSchemaGroupRef refGroup = (XmlSchemaGroupRef)particle; particle = ((XmlSchemaGroup)schemas.Find(refGroup.RefName, typeof(XmlSchemaGroup), false)).Particle; } else if (particle is XmlSchemaGroupBase) { particle = (XmlSchemaGroupBase)particle; } } else if (item is XmlSchemaSimpleType) { XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)item; XmlSchemaSimpleTypeContent content = simpleType.Content; if (content is XmlSchemaSimpleTypeRestriction) { baseType = ((XmlSchemaSimpleTypeRestriction)content).BaseType; baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName; } else if (content is XmlSchemaSimpleTypeList) { XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)content; if (list.ItemTypeName != null && !list.ItemTypeName.IsEmpty) { baseName = list.ItemTypeName; } if (list.ItemType != null) { baseType = list.ItemType; } } else if (content is XmlSchemaSimpleTypeRestriction) { baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName; } else if (t == typeof(XmlSchemaSimpleTypeUnion)) { XmlQualifiedName[] memberTypes = ((XmlSchemaSimpleTypeUnion)item).MemberTypes; if (memberTypes != null) { for (int i = 0; i < memberTypes.Length; i++) { XmlSchemaType type = (XmlSchemaType)schemas.Find(memberTypes[i], typeof(XmlSchemaType), false); AddRef(refs, type); } } } } if (baseType == null && !baseName.IsEmpty && baseName.Namespace != XmlSchema.Namespace) { baseType = (XmlSchemaType)schemas.Find(baseName, typeof(XmlSchemaType), false); } if (baseType != null) { AddRef(refs, baseType); } if (particle != null) { Depends(particle, refs); } if (attributes != null) { for (int i = 0; i < attributes.Count; i++) { Depends(attributes[i], refs); } } } else if (t == typeof(XmlSchemaElement)) { XmlSchemaElement el = (XmlSchemaElement)item; if (!el.SubstitutionGroup.IsEmpty) { if (el.SubstitutionGroup.Namespace != XmlSchema.Namespace) { XmlSchemaElement head = (XmlSchemaElement)schemas.Find(el.SubstitutionGroup, typeof(XmlSchemaElement), false); AddRef(refs, head); } } if (!el.RefName.IsEmpty) { el = (XmlSchemaElement)schemas.Find(el.RefName, typeof(XmlSchemaElement), false); AddRef(refs, el); } else if (!el.SchemaTypeName.IsEmpty) { XmlSchemaType type = (XmlSchemaType)schemas.Find(el.SchemaTypeName, typeof(XmlSchemaType), false); AddRef(refs, type); } else { Depends(el.SchemaType, refs); } } else if (t == typeof(XmlSchemaGroup)) { Depends(((XmlSchemaGroup)item).Particle); } else if (t == typeof(XmlSchemaGroupRef)) { XmlSchemaGroup group = (XmlSchemaGroup)schemas.Find(((XmlSchemaGroupRef)item).RefName, typeof(XmlSchemaGroup), false); AddRef(refs, group); } else if (typeof(XmlSchemaGroupBase).IsAssignableFrom(t)) { foreach (XmlSchemaObject o in ((XmlSchemaGroupBase)item).Items) { Depends(o, refs); } } else if (t == typeof(XmlSchemaAttributeGroupRef)) { XmlSchemaAttributeGroup group = (XmlSchemaAttributeGroup)schemas.Find(((XmlSchemaAttributeGroupRef)item).RefName, typeof(XmlSchemaAttributeGroup), false); AddRef(refs, group); } else if (t == typeof(XmlSchemaAttributeGroup)) { foreach (XmlSchemaObject o in ((XmlSchemaAttributeGroup)item).Attributes) { Depends(o, refs); } } else if (t == typeof(XmlSchemaAttribute)) { XmlSchemaAttribute at = (XmlSchemaAttribute)item; if (!at.RefName.IsEmpty) { at = (XmlSchemaAttribute)schemas.Find(at.RefName, typeof(XmlSchemaAttribute), false); AddRef(refs, at); } else if (!at.SchemaTypeName.IsEmpty) { XmlSchemaType type = (XmlSchemaType)schemas.Find(at.SchemaTypeName, typeof(XmlSchemaType), false); AddRef(refs, type); } else { Depends(at.SchemaType, refs); } } if (typeof(XmlSchemaAnnotated).IsAssignableFrom(t)) { XmlAttribute[] attrs = (XmlAttribute[])((XmlSchemaAnnotated)item).UnhandledAttributes; if (attrs != null) { for (int i = 0; i < attrs.Length; i++) { XmlAttribute attribute = attrs[i]; if (attribute.LocalName == Wsdl.ArrayType && attribute.NamespaceURI == Wsdl.Namespace) { string dims; XmlQualifiedName qname = TypeScope.ParseWsdlArrayType(attribute.Value, out dims, item); XmlSchemaType type = (XmlSchemaType)schemas.Find(qname, typeof(XmlSchemaType), false); AddRef(refs, type); } } } } }
/// <summary> /// Creates the an xml schema for a complex type. This method automatically takes care of /// any base classes that must be added. /// <para /> /// This method already adds the <see cref="XmlSchemaComplexType" /> to the <see cref="XmlSchemaSet" />. /// </summary> /// <param name="type">The type to create the complex schema for.</param> /// <param name="schema">The schema.</param> /// <param name="schemaSet">The schema set.</param> /// <param name="serializationManager">The serialization manager.</param> /// <param name="generateFlatSchema">A value indicating whether the schema should be generated as flat schema.</param> /// <param name="exportedTypes">The exported types.</param> /// <returns>The complex schema for the specified type.</returns> private static XmlSchemaComplexType CreateSchemaComplexType(Type type, XmlSchema schema, XmlSchemaSet schemaSet, ISerializationManager serializationManager, bool generateFlatSchema, HashSet <string> exportedTypes) { // Determine name, which is complex in generic types string typeName = GetTypeNameForSchema(type); // First, add the type, otherwise we might get into a stackoverflow when using generic base types // <xs:complexType> var modelBaseType = new XmlSchemaComplexType(); modelBaseType.Name = typeName; modelBaseType.IsMixed = false; schema.Items.Add(modelBaseType); var propertiesSequence = GetPropertiesSequence(type, schema, schemaSet, serializationManager, exportedTypes); // If flat, don't generate base classes, just the type itself if (generateFlatSchema) { modelBaseType.Particle = propertiesSequence; return(modelBaseType); } if (type.IsGenericType) { var genericComplexType = new XmlSchemaComplexType(); genericComplexType.Name = typeName; // <xs:annotation> var annotation = new XmlSchemaAnnotation(); // <xs:appinfo> var appInfo = new XmlSchemaAppInfo(); //<GenericType xmlns="http://schemas.microsoft.com/2003/10/Serialization/" Name="DataContractBaseOf{0}{#}" Namespace="http://schemas.datacontract.org/2004/07/STC"> // <GenericParameter Name="ProfileDateRange2" Namespace="http://schemas.datacontract.org/2004/07/STC.Meter.ProfileData"/> //</GenericType> var genericTypeElement = new XElement("GenericType"); genericTypeElement.Add(new XAttribute("Name", string.Format("{0}Of{{0}}{{#}}", typeName))); genericTypeElement.Add(new XAttribute("Namespace", GetTypeNamespaceForSchema(type))); foreach (var genericArgument in type.GetGenericArgumentsEx()) { var genericArgumentQualifiedName = AddTypeToSchemaSet(genericArgument, schemaSet, serializationManager, exportedTypes); var genericArgumentElement = new XElement("GenericParameter"); genericArgumentElement.Add(new XAttribute("Name", genericArgumentQualifiedName.Name)); genericArgumentElement.Add(new XAttribute("Namespace", genericArgumentQualifiedName.Namespace)); genericTypeElement.Add(genericArgumentElement); } var conversionDoc = new XmlDocument(); appInfo.Markup = new XmlNode[] { conversionDoc.CreateTextNode(genericTypeElement.ToString()) }; annotation.Items.Add(appInfo); } var baseTypeQualifiedName = AddTypeToSchemaSet(type.BaseType, schemaSet, serializationManager, exportedTypes); if (baseTypeQualifiedName != null) { // <xs:extensions base="address"> var complexContentExtension = new XmlSchemaComplexContentExtension(); complexContentExtension.BaseTypeName = baseTypeQualifiedName; complexContentExtension.Particle = propertiesSequence; // <xs:complexContent> var complexContent = new XmlSchemaComplexContent(); complexContent.Content = complexContentExtension; modelBaseType.ContentModel = complexContent; } else { modelBaseType.Particle = propertiesSequence; } return(modelBaseType); }
XmlSchemaAttribute FindAttribute(XmlSchemaComplexContentExtension extension, string name) { return(FindAttribute(extension.Attributes, name)); }
public XmlSchemaComplexType FindBaseType(XmlSchemaObject baseObject) { if (baseObject is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension baseComplexContentExtension = baseObject as XmlSchemaComplexContentExtension; return(FindComplexType(baseComplexContentExtension)); } if (baseObject is XmlSchemaComplexType) { XmlSchemaComplexType baseComplexType = baseObject as XmlSchemaComplexType; if (baseComplexType.Parent is XmlSchemaElement) { XmlSchemaElement baseElement = baseComplexType.Parent as XmlSchemaElement; XmlSchemaIdentityConstraint primaryKey = FindPrimaryKey(baseElement); if (primaryKey == null) { return(null); } foreach (XmlSchemaObject xmlSchemaObject in RootSchema.Items) { if (xmlSchemaObject is XmlSchemaElement) { if (IsDataSetElement(xmlSchemaObject)) { XmlSchemaElement dataSetElement = xmlSchemaObject as XmlSchemaElement; foreach (XmlSchemaIdentityConstraint xmlSchemaIdentityConstraint in dataSetElement.Constraints) { if (xmlSchemaIdentityConstraint is XmlSchemaKeyref) { XmlSchemaKeyref xmlSchemaKeyref = xmlSchemaIdentityConstraint as XmlSchemaKeyref; if (this.FindSelector(xmlSchemaKeyref) == baseElement) { bool isMatch = xmlSchemaKeyref.Fields.Count == primaryKey.Fields.Count; for (int index = 0; index < xmlSchemaKeyref.Fields.Count; index++) { XmlSchemaXPath xPath1 = (XmlSchemaXPath)xmlSchemaKeyref.Fields[index]; XmlSchemaXPath xPath2 = (XmlSchemaXPath)primaryKey.Fields[index]; if (xPath1.XPath != xPath2.XPath) { isMatch = false; break; } } if (isMatch) { XmlSchemaIdentityConstraint xmlSchemaKey = FindKey(xmlSchemaKeyref); XmlSchemaElement xmlSchemaElement = FindSelector(xmlSchemaKey); return(xmlSchemaElement.SchemaType as XmlSchemaComplexType); } } } } } else { XmlSchemaElement tableElement = xmlSchemaObject as XmlSchemaElement; foreach (XmlSchemaIdentityConstraint xmlSchemaIdentityConstraint in tableElement.Constraints) { } } } } return(null); } } return(null); }