C# XmlSchemaComplexType.SetDatatype方法代碼示例

 private void CompileSimpleContentRestriction(XmlSchemaComplexType complexType, XmlSchemaSimpleContentRestriction simpleRestriction)
 {
     XmlSchemaComplexType redefined = null;
     XmlSchemaDatatype datatype = null;
     if ((complexType.Redefined != null) && (simpleRestriction.BaseTypeName == complexType.Redefined.QualifiedName))
     {
         redefined = (XmlSchemaComplexType) complexType.Redefined;
         this.CompileComplexType(redefined);
         datatype = redefined.Datatype;
     }
     else
     {
         redefined = this.GetComplexType(simpleRestriction.BaseTypeName);
         if (redefined == null)
         {
             base.SendValidationEvent("Sch_UndefBaseRestriction", simpleRestriction.BaseTypeName.ToString(), simpleRestriction);
             return;
         }
         if (redefined.ContentType == XmlSchemaContentType.TextOnly)
         {
             if (simpleRestriction.BaseType == null)
             {
                 datatype = redefined.Datatype;
             }
             else
             {
                 this.CompileSimpleType(simpleRestriction.BaseType);
                 if (!XmlSchemaType.IsDerivedFromDatatype(simpleRestriction.BaseType.Datatype, redefined.Datatype, XmlSchemaDerivationMethod.None))
                 {
                     base.SendValidationEvent("Sch_DerivedNotFromBase", simpleRestriction);
                 }
                 datatype = simpleRestriction.BaseType.Datatype;
             }
         }
         else if ((redefined.ContentType == XmlSchemaContentType.Mixed) && redefined.ElementDecl.ContentValidator.IsEmptiable)
         {
             if (simpleRestriction.BaseType != null)
             {
                 this.CompileSimpleType(simpleRestriction.BaseType);
                 complexType.SetBaseSchemaType(simpleRestriction.BaseType);
                 datatype = simpleRestriction.BaseType.Datatype;
             }
             else
             {
                 base.SendValidationEvent("Sch_NeedSimpleTypeChild", simpleRestriction);
             }
         }
         else
         {
             base.SendValidationEvent("Sch_NotSimpleContent", complexType);
         }
     }
     if (((redefined != null) && (redefined.ElementDecl != null)) && ((redefined.FinalResolved & XmlSchemaDerivationMethod.Restriction) != XmlSchemaDerivationMethod.Empty))
     {
         base.SendValidationEvent("Sch_BaseFinalRestriction", complexType);
     }
     if (redefined != null)
     {
         complexType.SetBaseSchemaType(redefined);
     }
     if (datatype != null)
     {
         try
         {
             complexType.SetDatatype(datatype.DeriveByRestriction(simpleRestriction.Facets, base.NameTable, complexType));
         }
         catch (XmlSchemaException exception)
         {
             if (exception.SourceSchemaObject == null)
             {
                 exception.SetSource(complexType);
             }
             base.SendValidationEvent(exception);
             complexType.SetDatatype(DatatypeImplementation.AnySimpleType.Datatype);
         }
     }
     complexType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
     this.CompileLocalAttributes(redefined, complexType, simpleRestriction.Attributes, simpleRestriction.AnyAttribute, XmlSchemaDerivationMethod.Restriction);
 }

 private void CompileSimpleContentExtension(XmlSchemaComplexType complexType, XmlSchemaSimpleContentExtension simpleExtension)
 {
     XmlSchemaComplexType redefined = null;
     if ((complexType.Redefined != null) && (simpleExtension.BaseTypeName == complexType.Redefined.QualifiedName))
     {
         redefined = (XmlSchemaComplexType) complexType.Redefined;
         this.CompileComplexType(redefined);
         complexType.SetBaseSchemaType(redefined);
         complexType.SetDatatype(redefined.Datatype);
     }
     else
     {
         XmlSchemaType anySchemaType = this.GetAnySchemaType(simpleExtension.BaseTypeName);
         if (anySchemaType == null)
         {
             base.SendValidationEvent("Sch_UndeclaredType", simpleExtension.BaseTypeName.ToString(), complexType);
         }
         else
         {
             complexType.SetBaseSchemaType(anySchemaType);
             complexType.SetDatatype(anySchemaType.Datatype);
         }
         redefined = anySchemaType as XmlSchemaComplexType;
     }
     if (redefined != null)
     {
         if ((redefined.FinalResolved & XmlSchemaDerivationMethod.Extension) != XmlSchemaDerivationMethod.Empty)
         {
             base.SendValidationEvent("Sch_BaseFinalExtension", complexType);
         }
         if (redefined.ContentType != XmlSchemaContentType.TextOnly)
         {
             base.SendValidationEvent("Sch_NotSimpleContent", complexType);
         }
     }
     complexType.SetDerivedBy(XmlSchemaDerivationMethod.Extension);
     this.CompileLocalAttributes(redefined, complexType, simpleExtension.Attributes, simpleExtension.AnyAttribute, XmlSchemaDerivationMethod.Extension);
 }

        private void CompileComplexContentExtension(XmlSchemaComplexType complexType, XmlSchemaComplexContent complexContent, XmlSchemaComplexContentExtension complexExtension) {
            XmlSchemaComplexType baseType = null;
            if (complexType.Redefined != null && complexExtension.BaseTypeName == complexType.Redefined.QualifiedName) {
                baseType = (XmlSchemaComplexType)complexType.Redefined;
                CompileComplexType(baseType);
            }
            else {
                baseType = GetComplexType(complexExtension.BaseTypeName);
                if (baseType == null) {
                    SendValidationEvent(Res.Sch_UndefBaseExtension, complexExtension.BaseTypeName.ToString(), complexExtension);   
                    return;
                }
            }
            if ((baseType.FinalResolved & XmlSchemaDerivationMethod.Extension) != 0) {
                SendValidationEvent(Res.Sch_BaseFinalExtension, complexType);
            }
            CompileLocalAttributes(baseType, complexType, complexExtension.Attributes, complexExtension.AnyAttribute, XmlSchemaDerivationMethod.Extension);

            XmlSchemaParticle baseParticle = baseType.ContentTypeParticle;
            XmlSchemaParticle extendedParticle = CannonicalizeParticle(complexExtension.Particle, true);
            if (baseParticle != XmlSchemaParticle.Empty) {
                if (extendedParticle != XmlSchemaParticle.Empty) {
                    XmlSchemaSequence compiledParticle = new XmlSchemaSequence();
                    compiledParticle.Items.Add(baseParticle);
                    compiledParticle.Items.Add(extendedParticle);
                    complexType.SetContentTypeParticle(CompileContentTypeParticle(compiledParticle));
                }
                else {
                    complexType.SetContentTypeParticle(baseParticle);
                }
            }
            else {
                complexType.SetContentTypeParticle(extendedParticle);
            }
            XmlSchemaContentType contentType = GetSchemaContentType(complexType, complexContent, extendedParticle);
            if (contentType == XmlSchemaContentType.Empty) { //Derived content type is empty, Get ContentType from base
                contentType = baseType.ContentType;
                // In case of a simple base type (content type is TextOnly) the derived type
                //   will be the same as the base type. So set the same content type and then also
                //   set the same data type.
                if (contentType == XmlSchemaContentType.TextOnly) {
                    complexType.SetDatatype(baseType.Datatype);
                }
            }
            complexType.SetContentType(contentType);

            if (baseType.ContentType != XmlSchemaContentType.Empty && complexType.ContentType != baseType.ContentType) { //If base is empty, do not check
                SendValidationEvent(Res.Sch_DifContentType, complexType);
                return;
            }
            complexType.SetBaseSchemaType(baseType);
            complexType.SetDerivedBy(XmlSchemaDerivationMethod.Extension);
        }

 private void CompileSimpleContentRestriction(XmlSchemaComplexType complexType, XmlSchemaSimpleContentRestriction simpleRestriction) {
     XmlSchemaComplexType baseType = null;
     XmlSchemaDatatype datatype = null;
     if (complexType.Redefined != null && simpleRestriction.BaseTypeName == complexType.Redefined.QualifiedName) {
         baseType = (XmlSchemaComplexType)complexType.Redefined;
         CompileComplexType(baseType);
         datatype = baseType.Datatype;
     }
     else {
         baseType = GetComplexType(simpleRestriction.BaseTypeName);
         if (baseType == null) {
             SendValidationEvent(Res.Sch_UndefBaseRestriction, simpleRestriction.BaseTypeName.ToString(), simpleRestriction);
             return;
         }
         if (baseType.ContentType == XmlSchemaContentType.TextOnly) {
             if (simpleRestriction.BaseType == null) { 
                 datatype = baseType.Datatype; 
                 //There is a bug here. Need to check if simpleRestriction has facets.
                 //If yes, Need tp apply these facets as well. 
             }
             else {
                 CompileSimpleType(simpleRestriction.BaseType);
                 if(!XmlSchemaType.IsDerivedFromDatatype(simpleRestriction.BaseType.Datatype, baseType.Datatype, XmlSchemaDerivationMethod.None)) {
                    SendValidationEvent(Res.Sch_DerivedNotFromBase, simpleRestriction);
                 }
                 datatype = simpleRestriction.BaseType.Datatype;
             }
         }
         else if (baseType.ContentType == XmlSchemaContentType.Mixed && baseType.ElementDecl.ContentValidator.IsEmptiable) {
             if (simpleRestriction.BaseType != null) {
                 CompileSimpleType(simpleRestriction.BaseType);
                 complexType.SetBaseSchemaType(simpleRestriction.BaseType);
                 datatype = simpleRestriction.BaseType.Datatype;
             }
             else {
                 SendValidationEvent(Res.Sch_NeedSimpleTypeChild, simpleRestriction);
             }
         }
         else {
             SendValidationEvent(Res.Sch_NotSimpleContent, complexType);
         }
     }
     if (baseType != null && baseType.ElementDecl != null) {
         if ((baseType.FinalResolved & XmlSchemaDerivationMethod.Restriction) != 0) {
             SendValidationEvent(Res.Sch_BaseFinalRestriction, complexType);
         }
     }
     if (baseType != null) {
         complexType.SetBaseSchemaType(baseType);
     }
     if (datatype != null) {
         try {
             complexType.SetDatatype(datatype.DeriveByRestriction(simpleRestriction.Facets, NameTable, complexType));
         }
         catch (XmlSchemaException e) {
             if (e.SourceSchemaObject == null) {
                 e.SetSource(complexType);
             }
             SendValidationEvent(e);
             complexType.SetDatatype(DatatypeImplementation.AnySimpleType.Datatype);
         } 
     }
     complexType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
     CompileLocalAttributes(baseType, complexType, simpleRestriction.Attributes, simpleRestriction.AnyAttribute, XmlSchemaDerivationMethod.Restriction);
 }

 private void CompileSimpleContentExtension(XmlSchemaComplexType complexType, XmlSchemaSimpleContentExtension simpleExtension) {
     XmlSchemaComplexType baseType = null;
     if (complexType.Redefined != null && simpleExtension.BaseTypeName == complexType.Redefined.QualifiedName) {
         baseType = (XmlSchemaComplexType)complexType.Redefined;
         CompileComplexType(baseType);
         complexType.SetBaseSchemaType(baseType);
         complexType.SetDatatype(baseType.Datatype);
     }
     else {
         XmlSchemaType bto = GetAnySchemaType(simpleExtension.BaseTypeName);
         if (bto == null) {
             SendValidationEvent(Res.Sch_UndeclaredType, simpleExtension.BaseTypeName.ToString(), simpleExtension);   
         } 
         else {
             complexType.SetBaseSchemaType(bto);
             complexType.SetDatatype(bto.Datatype);
         }
         baseType = bto as XmlSchemaComplexType;
     }
     if (baseType != null) {
         if ((baseType.FinalResolved & XmlSchemaDerivationMethod.Extension) != 0) {
             SendValidationEvent(Res.Sch_BaseFinalExtension, complexType);
         }
         if (baseType.ContentType != XmlSchemaContentType.TextOnly) {
             SendValidationEvent(Res.Sch_NotSimpleContent, complexType);
         }
     } 
     complexType.SetDerivedBy(XmlSchemaDerivationMethod.Extension);
     CompileLocalAttributes(baseType, complexType, simpleExtension.Attributes, simpleExtension.AnyAttribute, XmlSchemaDerivationMethod.Extension);
 }

 private void CompileComplexContentExtension(XmlSchemaComplexType complexType, XmlSchemaComplexContent complexContent, XmlSchemaComplexContentExtension complexExtension)
 {
     XmlSchemaComplexType redefined = null;
     if ((complexType.Redefined != null) && (complexExtension.BaseTypeName == complexType.Redefined.QualifiedName))
     {
         redefined = (XmlSchemaComplexType) complexType.Redefined;
         this.CompileComplexType(redefined);
     }
     else
     {
         redefined = this.GetComplexType(complexExtension.BaseTypeName);
         if (redefined == null)
         {
             base.SendValidationEvent("Sch_UndefBaseExtension", complexExtension.BaseTypeName.ToString(), complexExtension);
             return;
         }
     }
     if ((redefined.FinalResolved & XmlSchemaDerivationMethod.Extension) != XmlSchemaDerivationMethod.Empty)
     {
         base.SendValidationEvent("Sch_BaseFinalExtension", complexType);
     }
     this.CompileLocalAttributes(redefined, complexType, complexExtension.Attributes, complexExtension.AnyAttribute, XmlSchemaDerivationMethod.Extension);
     XmlSchemaParticle contentTypeParticle = redefined.ContentTypeParticle;
     XmlSchemaParticle item = this.CannonicalizeParticle(complexExtension.Particle, true);
     if (contentTypeParticle != XmlSchemaParticle.Empty)
     {
         if (item != XmlSchemaParticle.Empty)
         {
             XmlSchemaSequence particle = new XmlSchemaSequence();
             particle.Items.Add(contentTypeParticle);
             particle.Items.Add(item);
             complexType.SetContentTypeParticle(this.CompileContentTypeParticle(particle));
         }
         else
         {
             complexType.SetContentTypeParticle(contentTypeParticle);
         }
     }
     else
     {
         complexType.SetContentTypeParticle(item);
     }
     XmlSchemaContentType contentType = this.GetSchemaContentType(complexType, complexContent, item);
     if (contentType == XmlSchemaContentType.Empty)
     {
         contentType = redefined.ContentType;
         if (contentType == XmlSchemaContentType.TextOnly)
         {
             complexType.SetDatatype(redefined.Datatype);
         }
     }
     complexType.SetContentType(contentType);
     if ((redefined.ContentType != XmlSchemaContentType.Empty) && (complexType.ContentType != redefined.ContentType))
     {
         base.SendValidationEvent("Sch_DifContentType", complexType);
     }
     else
     {
         complexType.SetBaseSchemaType(redefined);
         complexType.SetDerivedBy(XmlSchemaDerivationMethod.Extension);
     }
 }