C# XmlSchemaAnyAttribute.BuildNamespaceList方法代碼示例

 static XmlSchemaComplexType() {
     anyType = new XmlSchemaComplexType();
     anyType.SetContentType(XmlSchemaContentType.Mixed);
     anyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
     XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute();
     anyAttribute.BuildNamespaceList(null);
     anyType.SetAttributeWildcard(anyAttribute);
     anyType.ElementDecl.AnyAttribute = anyAttribute;
 }

 private void PreprocessAttributes(XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute, XmlSchemaObject parent)
 {
     for (int i = 0; i < attributes.Count; i++)
     {
         this.SetParent(attributes[i], parent);
         XmlSchemaAttribute attribute = attributes[i] as XmlSchemaAttribute;
         if (attribute != null)
         {
             this.PreprocessLocalAttribute(attribute);
         }
         else
         {
             XmlSchemaAttributeGroupRef source = (XmlSchemaAttributeGroupRef) attributes[i];
             if (source.RefName.IsEmpty)
             {
                 base.SendValidationEvent("Sch_MissAttribute", "ref", source);
             }
             else
             {
                 this.ValidateQNameAttribute(source, "ref", source.RefName);
             }
             this.PreprocessAnnotation(attributes[i]);
             this.ValidateIdAttribute(attributes[i]);
         }
     }
     if (anyAttribute != null)
     {
         try
         {
             this.SetParent(anyAttribute, parent);
             this.PreprocessAnnotation(anyAttribute);
             anyAttribute.BuildNamespaceList(this.targetNamespace);
         }
         catch (FormatException exception)
         {
             base.SendValidationEvent("Sch_InvalidAnyDetailed", new string[] { exception.Message }, exception, anyAttribute);
         }
         this.ValidateIdAttribute(anyAttribute);
     }
 }

 private void PreprocessAttributes(XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute, XmlSchemaObject parent) {
     for (int i = 0; i < attributes.Count; ++i) {
         SetParent(attributes[i], parent);
         XmlSchemaAttribute attr = attributes[i] as XmlSchemaAttribute;
         if (attr != null) {
             PreprocessLocalAttribute(attr);
         } 
         else { // XmlSchemaAttributeGroupRef
             XmlSchemaAttributeGroupRef attributeGroupRef = (XmlSchemaAttributeGroupRef)attributes[i];
             if (attributeGroupRef.RefName.IsEmpty) {
                 SendValidationEvent(Res.Sch_MissAttribute, "ref", attributeGroupRef);
             }
             else {
                 ValidateQNameAttribute(attributeGroupRef, "ref", attributeGroupRef.RefName);
             }
             PreprocessAnnotation(attributes[i]); //set parent of annotation child of attributeGroupRef
             ValidateIdAttribute(attributes[i]);
         }
     }
     if (anyAttribute != null) {
         try {
             SetParent(anyAttribute, parent);
             PreprocessAnnotation(anyAttribute); //set parent of annotation child of any attribute
             anyAttribute.BuildNamespaceList(this.targetNamespace);
         } 
         catch(FormatException fe) {
             SendValidationEvent(Res.Sch_InvalidAnyDetailed, new string[] {fe.Message}, fe, anyAttribute);
         }
         ValidateIdAttribute(anyAttribute);
     }
 }

        static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents) {
            XmlSchemaComplexType localAnyType = new XmlSchemaComplexType();
            localAnyType.SetQualifiedName(DatatypeImplementation.QnAnyType);

            XmlSchemaAny anyElement = new XmlSchemaAny();
            anyElement.MinOccurs = decimal.Zero;
            anyElement.MaxOccurs = decimal.MaxValue;

            anyElement.ProcessContents = processContents;
            anyElement.BuildNamespaceList(null);
            XmlSchemaSequence seq = new XmlSchemaSequence();
            seq.Items.Add(anyElement);

            localAnyType.SetContentTypeParticle(seq);
            localAnyType.SetContentType(XmlSchemaContentType.Mixed);

            localAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
            localAnyType.ElementDecl.SchemaType = localAnyType;

            //Create contentValidator for Any
            ParticleContentValidator contentValidator = new ParticleContentValidator(XmlSchemaContentType.Mixed);
            contentValidator.Start();
            contentValidator.OpenGroup();
            contentValidator.AddNamespaceList(anyElement.NamespaceList, anyElement);
            contentValidator.AddStar();
            contentValidator.CloseGroup();
            ContentValidator anyContentValidator = contentValidator.Finish(true);
            localAnyType.ElementDecl.ContentValidator = anyContentValidator;

            XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute();
            anyAttribute.ProcessContents = processContents;
            anyAttribute.BuildNamespaceList(null);
            localAnyType.SetAttributeWildcard(anyAttribute);
            localAnyType.ElementDecl.AnyAttribute = anyAttribute;
            return localAnyType;
        }

 private void PreprocessAttributes(XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute) {
     foreach (XmlSchemaAnnotated obj in attributes) {
         if (obj is XmlSchemaAttribute) {
             PreprocessLocalAttribute((XmlSchemaAttribute)obj);
         } 
         else { // XmlSchemaAttributeGroupRef
             XmlSchemaAttributeGroupRef attributeGroupRef = (XmlSchemaAttributeGroupRef)obj;
             if (attributeGroupRef.RefName.IsEmpty) {
                 SendValidationEvent(Res.Sch_MissAttribute, "ref", attributeGroupRef);
             }
             else {
                 ValidateQNameAttribute(attributeGroupRef, "ref", attributeGroupRef.RefName);
             }
             ValidateIdAttribute(obj);
         }
     }
     if (anyAttribute != null) {
         try {
             anyAttribute.BuildNamespaceList(this.targetNamespace);
         } 
         catch {
             SendValidationEvent(Res.Sch_InvalidAnyAttribute, anyAttribute);
         }
         ValidateIdAttribute(anyAttribute);
     }
 }

 private static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents)
 {
     XmlSchemaComplexType type = new XmlSchemaComplexType();
     type.SetQualifiedName(DatatypeImplementation.QnAnyType);
     XmlSchemaAny item = new XmlSchemaAny {
         MinOccurs = 0M,
         MaxOccurs = 79228162514264337593543950335M,
         ProcessContents = processContents
     };
     item.BuildNamespaceList(null);
     XmlSchemaSequence sequence = new XmlSchemaSequence();
     sequence.Items.Add(item);
     type.SetContentTypeParticle(sequence);
     type.SetContentType(XmlSchemaContentType.Mixed);
     type.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
     type.ElementDecl.SchemaType = type;
     ParticleContentValidator validator = new ParticleContentValidator(XmlSchemaContentType.Mixed);
     validator.Start();
     validator.OpenGroup();
     validator.AddNamespaceList(item.NamespaceList, item);
     validator.AddStar();
     validator.CloseGroup();
     ContentValidator validator2 = validator.Finish(true);
     type.ElementDecl.ContentValidator = validator2;
     XmlSchemaAnyAttribute attribute = new XmlSchemaAnyAttribute {
         ProcessContents = processContents
     };
     attribute.BuildNamespaceList(null);
     type.SetAttributeWildcard(attribute);
     type.ElementDecl.AnyAttribute = attribute;
     return type;
 }