C# Schema.ValidationState类代码示例

 public override object ValidateElement(XmlQualifiedName name, ValidationState context, out int errorCode)
 {
     object obj2 = this.elements[name];
     errorCode = 0;
     if (obj2 == null)
     {
         context.NeedValidateChildren = false;
         return null;
     }
     int index = (int) obj2;
     if (context.AllElementsSet[index])
     {
         errorCode = -2;
         return null;
     }
     if (context.CurrentState.AllElementsRequired == -1)
     {
         context.CurrentState.AllElementsRequired = 0;
     }
     context.AllElementsSet.Set(index);
     if (this.isRequired[index])
     {
         context.CurrentState.AllElementsRequired++;
     }
     return this.particles[index];
 }

 public override ArrayList ExpectedElements(ValidationState context, bool isRequiredOnly)
 {
     ArrayList list = null;
     BitSet set = context.CurPos[context.CurrentState.CurPosIndex];
     for (int i = set.NextSet(-1); i != -1; i = set.NextSet(i))
     {
         if (list == null)
         {
             list = new ArrayList();
         }
         XmlSchemaParticle particle = (XmlSchemaParticle) this.positions[i].particle;
         if (particle == null)
         {
             string str = this.symbols.NameOf(this.positions[i].symbol);
             if (str.Length != 0)
             {
                 list.Add(str);
             }
         }
         else
         {
             string nameString = particle.NameString;
             if (!list.Contains(nameString))
             {
                 list.Add(nameString);
             }
         }
     }
     return list;
 }

 public override bool CompleteValidation(ValidationState context)
 {
     if (!context.HasMatched)
     {
         return false;
     }
     return true;
 }

 public override bool CompleteValidation(ValidationState context)
 {
     if ((context.CurrentState.AllElementsRequired != this.countRequired) && (!this.IsEmptiable || (context.CurrentState.AllElementsRequired != -1)))
     {
         return false;
     }
     return true;
 }

 public override bool CompleteValidation(ValidationState context)
 {
     if (!context.CurPos[context.CurrentState.CurPosIndex][this.endMarkerPos])
     {
         return false;
     }
     return true;
 }

 public virtual object ValidateElement(XmlQualifiedName name, ValidationState context, out int errorCode)
 {
     if ((this.contentType == XmlSchemaContentType.TextOnly) || (this.contentType == XmlSchemaContentType.Empty))
     {
         context.NeedValidateChildren = false;
     }
     errorCode = -1;
     return null;
 }

 public override ArrayList ExpectedParticles(ValidationState context, bool isRequiredOnly, XmlSchemaSet schemaSet)
 {
     ArrayList particles = new ArrayList();
     foreach (DictionaryEntry entry in this.elements)
     {
         if (!context.AllElementsSet[(int) entry.Value] && (!isRequiredOnly || this.isRequired[(int) entry.Value]))
         {
             ContentValidator.AddParticleToExpected(this.particles[(int) entry.Value] as XmlSchemaParticle, schemaSet, particles);
         }
     }
     return particles;
 }

 public override ArrayList ExpectedParticles(ValidationState context, bool isRequiredOnly, XmlSchemaSet schemaSet)
 {
     ArrayList particles = new ArrayList();
     BitSet set = context.CurPos[context.CurrentState.CurPosIndex];
     for (int i = set.NextSet(-1); i != -1; i = set.NextSet(i))
     {
         XmlSchemaParticle p = (XmlSchemaParticle) this.positions[i].particle;
         if (p != null)
         {
             ContentValidator.AddParticleToExpected(p, schemaSet, particles);
         }
     }
     return particles;
 }

 public override ArrayList ExpectedElements(ValidationState context, bool isRequiredOnly)
 {
     ArrayList list = null;
     foreach (DictionaryEntry entry in this.elements)
     {
         if (!context.AllElementsSet[(int) entry.Value] && (!isRequiredOnly || this.isRequired[(int) entry.Value]))
         {
             if (list == null)
             {
                 list = new ArrayList();
             }
             list.Add(entry.Key);
         }
     }
     return list;
 }

 public override ArrayList ExpectedParticles(ValidationState context, bool isRequiredOnly, XmlSchemaSet schemaSet)
 {
     ArrayList particles = new ArrayList();
     int[] numArray = this.transitionTable[context.CurrentState.State];
     if (numArray != null)
     {
         for (int i = 0; i < (numArray.Length - 1); i++)
         {
             if (numArray[i] != -1)
             {
                 XmlSchemaParticle p = (XmlSchemaParticle) this.symbols.GetParticle(i);
                 if (p != null)
                 {
                     ContentValidator.AddParticleToExpected(p, schemaSet, particles);
                 }
             }
         }
     }
     return particles;
 }

 public override ArrayList ExpectedElements(ValidationState context, bool isRequiredOnly)
 {
     ArrayList list = null;
     int[] numArray = this.transitionTable[context.CurrentState.State];
     if (numArray != null)
     {
         for (int i = 0; i < (numArray.Length - 1); i++)
         {
             if (numArray[i] != -1)
             {
                 if (list == null)
                 {
                     list = new ArrayList();
                 }
                 XmlSchemaParticle particle = (XmlSchemaParticle) this.symbols.GetParticle(i);
                 if (particle == null)
                 {
                     string str = this.symbols.NameOf(i);
                     if (str.Length != 0)
                     {
                         list.Add(str);
                     }
                 }
                 else
                 {
                     string nameString = particle.NameString;
                     if (!list.Contains(nameString))
                     {
                         list.Add(nameString);
                     }
                 }
             }
         }
     }
     return list;
 }

 public override bool CompleteValidation(ValidationState context) {
     if (context.CurrentState.AllElementsRequired == countRequired || IsEmptiable && context.CurrentState.AllElementsRequired == -1) {
         return true;
     }
     return false;
 }

 public override void InitValidation(ValidationState context) {
     Debug.Assert(elements.Count > 0);
     context.AllElementsSet = new BitSet(elements.Count); //
     context.CurrentState.AllElementsRequired = -1; // no elements at all
 }

 internal static void CompleteValidationError(ValidationState context, System.Xml.Schema.ValidationEventHandler eventHandler, object sender, string sourceUri, int lineNo, int linePos, XmlSchemaSet schemaSet)
 {
     ArrayList expected = null;
     bool getParticles = schemaSet != null;
     if (context.ElementDecl != null)
     {
         if (getParticles)
         {
             expected = context.ElementDecl.ContentValidator.ExpectedParticles(context, true, schemaSet);
         }
         else
         {
             expected = context.ElementDecl.ContentValidator.ExpectedElements(context, true);
         }
     }
     if ((expected == null) || (expected.Count == 0))
     {
         if (context.TooComplex)
         {
             SendValidationEvent(eventHandler, sender, new XmlSchemaValidationException("Sch_IncompleteContentComplex", new string[] { BuildElementName(context.LocalName, context.Namespace), Res.GetString("Sch_ComplexContentModel") }, sourceUri, lineNo, linePos), XmlSeverityType.Error);
         }
         SendValidationEvent(eventHandler, sender, new XmlSchemaValidationException("Sch_IncompleteContent", BuildElementName(context.LocalName, context.Namespace), sourceUri, lineNo, linePos), XmlSeverityType.Error);
     }
     else if (context.TooComplex)
     {
         SendValidationEvent(eventHandler, sender, new XmlSchemaValidationException("Sch_IncompleteContentExpectingComplex", new string[] { BuildElementName(context.LocalName, context.Namespace), PrintExpectedElements(expected, getParticles), Res.GetString("Sch_ComplexContentModel") }, sourceUri, lineNo, linePos), XmlSeverityType.Error);
     }
     else
     {
         SendValidationEvent(eventHandler, sender, new XmlSchemaValidationException("Sch_IncompleteContentExpecting", new string[] { BuildElementName(context.LocalName, context.Namespace), PrintExpectedElements(expected, getParticles) }, sourceUri, lineNo, linePos), XmlSeverityType.Error);
     }
 }

 private void Pop()
 {
     ValidationState state = (ValidationState) this.validationStack.Pop();
     if (this.startIDConstraint == this.validationStack.Length)
     {
         this.startIDConstraint = -1;
     }
     this.context = (ValidationState) this.validationStack.Peek();
     if (state.Validity == XmlSchemaValidity.Invalid)
     {
         this.context.Validity = XmlSchemaValidity.Invalid;
     }
     if (state.ValidationSkipped)
     {
         this.context.ValidationSkipped = true;
     }
     this.processContents = this.context.ProcessContents;
 }