The Labs \ Source Viewer \ SSCLI \ System.Xml.Schema \ XdrValidator

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XdrValidator.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Xml.Schema
  16. {
  17.    
  18.     using System.IO;
  19.     using System.Text;
  20.     using System.Collections;
  21.     using System.Diagnostics;
  22.     using System.Globalization;
  23.    
  24.     #pragma warning disable 618
  25.     internal sealed class XdrValidator : BaseValidator
  26.     {
  27.        
  28.         private const int STACK_INCREMENT = 10;
  29.         private HWStack validationStack;
  30.         // validaton contexts
  31.         private Hashtable attPresence;
  32.         private XmlQualifiedName name = XmlQualifiedName.Empty;
  33.         private XmlNamespaceManager nsManager;
  34.         private bool isProcessContents = false;
  35.         private Hashtable IDs;
  36.         private IdRefNode idRefListHead;
  37.         private Parser inlineSchemaParser = null;
  38.         private const string x_schema = "x-schema:";
  39.        
  40.         internal XdrValidator(BaseValidator validator) : base(validator)
  41.         {
  42.             Init();
  43.         }
  44.        
  45.         internal XdrValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, ValidationEventHandler eventHandler) : base(reader, schemaCollection, eventHandler)
  46.         {
  47.             Init();
  48.         }
  49.        
  50.         private void Init()
  51.         {
  52.             nsManager = reader.NamespaceManager;
  53.             if (nsManager == null) {
  54.                 nsManager = new XmlNamespaceManager(NameTable);
  55.                 isProcessContents = true;
  56.             }
  57.             validationStack = new HWStack(STACK_INCREMENT);
  58.             textValue = new StringBuilder();
  59.             name = XmlQualifiedName.Empty;
  60.             attPresence = new Hashtable();
  61.             Push(XmlQualifiedName.Empty);
  62.             schemaInfo = new SchemaInfo();
  63.             checkDatatype = false;
  64.         }
  65.        
  66.         public override void Validate()
  67.         {
  68.             if (IsInlineSchemaStarted) {
  69.                 ProcessInlineSchema();
  70.             }
  71.             else {
  72.                 switch (reader.NodeType) {
  73.                     case XmlNodeType.Element:
  74.                         ValidateElement();
  75.                         if (reader.IsEmptyElement) {
  76.                             goto case XmlNodeType.EndElement;
  77.                         }
  78.                         break;
  79.                     case XmlNodeType.Whitespace:
  80.                         ValidateWhitespace();
  81.                         break;
  82.                     case XmlNodeType.Text:
  83.                     case XmlNodeType.CDATA:
  84.                     case XmlNodeType.SignificantWhitespace:
  85.                         // text inside a node
  86.                         // <![CDATA[...]]>
  87.                         ValidateText();
  88.                         break;
  89.                     case XmlNodeType.EndElement:
  90.                         ValidateEndElement();
  91.                         break;
  92.                 }
  93.             }
  94.         }
  95.        
  96.         private void ValidateElement()
  97.         {
  98.             elementName.Init(reader.LocalName, XmlSchemaDatatype.XdrCanonizeUri(reader.NamespaceURI, NameTable, SchemaNames));
  99.             ValidateChildElement();
  100.             if (SchemaNames.IsXDRRoot(elementName.Name, elementName.Namespace) && reader.Depth > 0) {
  101.                 inlineSchemaParser = new Parser(SchemaType.XDR, NameTable, SchemaNames, EventHandler);
  102.                 inlineSchemaParser.StartParsing(reader, null);
  103.                 inlineSchemaParser.ParseReaderNode();
  104.             }
  105.             else {
  106.                 ProcessElement();
  107.             }
  108.         }
  109.        
  110.         private void ValidateChildElement()
  111.         {
  112.             if (context.NeedValidateChildren) {
  113.                 int errorCode = 0;
  114.                 context.ElementDecl.ContentValidator.ValidateElement(elementName, context, out errorCode);
  115.                 if (errorCode < 0) {
  116.                     XmlSchemaValidator.ElementValidationError(elementName, context, EventHandler, reader, reader.BaseURI, PositionInfo.LineNumber, PositionInfo.LinePosition, false);
  117.                 }
  118.             }
  119.         }
  120.        
  121.         private bool IsInlineSchemaStarted {
  122.             get { return inlineSchemaParser != null; }
  123.         }
  124.        
  125.         private void ProcessInlineSchema()
  126.         {
  127.             if (!inlineSchemaParser.ParseReaderNode()) {
  128.                 // Done
  129.                 inlineSchemaParser.FinishParsing();
  130.                 SchemaInfo xdrSchema = inlineSchemaParser.XdrSchema;
  131.                 if (xdrSchema != null && xdrSchema.ErrorCount == 0) {
  132.                     foreach (string inlineNS in xdrSchema.TargetNamespaces.Keys) {
  133.                         if (!SchemaInfo.HasSchema(inlineNS)) {
  134.                             schemaInfo.Add(xdrSchema, EventHandler);
  135.                             SchemaCollection.Add(inlineNS, xdrSchema, null, false);
  136.                             break;
  137.                         }
  138.                     }
  139.                 }
  140.                 inlineSchemaParser = null;
  141.             }
  142.         }
  143.        
  144.         private void ProcessElement()
  145.         {
  146.             Push(elementName);
  147.             if (isProcessContents) {
  148.                 nsManager.PopScope();
  149.             }
  150.             context.ElementDecl = ThoroughGetElementDecl();
  151.             if (context.ElementDecl != null) {
  152.                 ValidateStartElement();
  153.                 ValidateEndStartElement();
  154.                 context.NeedValidateChildren = true;
  155.                 context.ElementDecl.ContentValidator.InitValidation(context);
  156.             }
  157.         }
  158.        
  159.         private void ValidateEndElement()
  160.         {
  161.             if (isProcessContents) {
  162.                 nsManager.PopScope();
  163.             }
  164.             if (context.ElementDecl != null) {
  165.                 if (context.NeedValidateChildren) {
  166.                     if (!context.ElementDecl.ContentValidator.CompleteValidation(context)) {
  167.                         XmlSchemaValidator.CompleteValidationError(context, EventHandler, reader, reader.BaseURI, PositionInfo.LineNumber, PositionInfo.LinePosition, false);
  168.                     }
  169.                 }
  170.                 if (checkDatatype) {
  171.                     string stringValue = !hasSibling ? textString : textValue.ToString();
  172.                     // only for identity-constraint exception reporting
  173.                     CheckValue(stringValue, null);
  174.                     checkDatatype = false;
  175.                     textValue.Length = 0;
  176.                     // cleanup
  177.                     textString = string.Empty;
  178.                 }
  179.             }
  180.             Pop();
  181.            
  182.         }
  183.        
  184.        
  185.         private SchemaElementDecl ThoroughGetElementDecl()
  186.         {
  187.             if (reader.Depth == 0) {
  188.                 LoadSchema(string.Empty);
  189.             }
  190.             if (reader.MoveToFirstAttribute()) {
  191.                 do {
  192.                     string objectNs = reader.NamespaceURI;
  193.                     string objectName = reader.LocalName;
  194.                     if (Ref.Equal(objectNs, SchemaNames.NsXmlNs)) {
  195.                         LoadSchema(reader.Value);
  196.                         if (isProcessContents) {
  197.                             nsManager.AddNamespace(reader.Prefix.Length == 0 ? string.Empty : reader.LocalName, reader.Value);
  198.                         }
  199.                     }
  200.                     if (Ref.Equal(objectNs, SchemaNames.QnDtDt.Namespace) && Ref.Equal(objectName, SchemaNames.QnDtDt.Name)) {
  201.                         reader.SchemaTypeObject = XmlSchemaDatatype.FromXdrName(reader.Value);
  202.                     }
  203.                    
  204.                 }
  205.                 while (reader.MoveToNextAttribute());
  206.                 reader.MoveToElement();
  207.             }
  208.             SchemaElementDecl elementDecl = schemaInfo.GetElementDecl(elementName);
  209.             if (elementDecl == null) {
  210.                 if (schemaInfo.TargetNamespaces.Contains(context.Namespace)) {
  211.                     SendValidationEvent(Res.Sch_UndeclaredElement, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
  212.                 }
  213.             }
  214.             return elementDecl;
  215.         }
  216.        
  217.         private void ValidateStartElement()
  218.         {
  219.             if (context.ElementDecl != null) {
  220.                 if (context.ElementDecl.SchemaType != null) {
  221.                     reader.SchemaTypeObject = context.ElementDecl.SchemaType;
  222.                 }
  223.                 else {
  224.                     reader.SchemaTypeObject = context.ElementDecl.Datatype;
  225.                 }
  226.                 if (reader.IsEmptyElement && !context.IsNill && context.ElementDecl.DefaultValueTyped != null) {
  227.                     reader.TypedValueObject = context.ElementDecl.DefaultValueTyped;
  228.                     context.IsNill = true;
  229.                     // reusing IsNill
  230.                 }
  231.                 if (this.context.ElementDecl.HasRequiredAttribute) {
  232.                     attPresence.Clear();
  233.                 }
  234.             }
  235.            
  236.             if (reader.MoveToFirstAttribute()) {
  237.                 do {
  238.                     if ((object)reader.NamespaceURI == (object)SchemaNames.NsXmlNs) {
  239.                         continue;
  240.                     }
  241.                    
  242.                     try {
  243.                         reader.SchemaTypeObject = null;
  244.                         SchemaAttDef attnDef = schemaInfo.GetAttributeXdr(context.ElementDecl, QualifiedName(reader.LocalName, reader.NamespaceURI));
  245.                         if (attnDef != null) {
  246.                             if (context.ElementDecl != null && context.ElementDecl.HasRequiredAttribute) {
  247.                                 attPresence.Add(attnDef.Name, attnDef);
  248.                             }
  249.                             reader.SchemaTypeObject = (attnDef.SchemaType != null) ? (object)attnDef.SchemaType : (object)attnDef.Datatype;
  250.                             if (attnDef.Datatype != null) {
  251.                                 string attributeValue = reader.Value;
  252.                                 // need to check the contents of this attribute to make sure
  253.                                 // it is valid according to the specified attribute type.
  254.                                 CheckValue(attributeValue, attnDef);
  255.                             }
  256.                         }
  257.                     }
  258.                     catch (XmlSchemaException e) {
  259.                         e.SetSource(reader.BaseURI, PositionInfo.LineNumber, PositionInfo.LinePosition);
  260.                         SendValidationEvent(e);
  261.                     }
  262.                 }
  263.                 while (reader.MoveToNextAttribute());
  264.                 reader.MoveToElement();
  265.             }
  266.         }
  267.        
  268.         private void ValidateEndStartElement()
  269.         {
  270.            
  271.             if (context.ElementDecl.HasDefaultAttribute) {
  272.                 foreach (SchemaAttDef attdef in context.ElementDecl.DefaultAttDefs) {
  273.                     reader.AddDefaultAttribute(attdef);
  274.                 }
  275.             }
  276.             if (context.ElementDecl.HasRequiredAttribute) {
  277.                 try {
  278.                     context.ElementDecl.CheckAttributes(attPresence, reader.StandAlone);
  279.                 }
  280.                 catch (XmlSchemaException e) {
  281.                     e.SetSource(reader.BaseURI, PositionInfo.LineNumber, PositionInfo.LinePosition);
  282.                     SendValidationEvent(e);
  283.                 }
  284.                
  285.             }
  286.             if (context.ElementDecl.Datatype != null) {
  287.                 checkDatatype = true;
  288.                 hasSibling = false;
  289.                 textString = string.Empty;
  290.                 textValue.Length = 0;
  291.             }
  292.         }
  293.        
  294.         private void LoadSchemaFromLocation(string uri)
  295.         {
  296.             // is x-schema
  297.             if (!XdrBuilder.IsXdrSchema(uri)) {
  298.                 return;
  299.             }
  300.             string url = uri.Substring(x_schema.Length);
  301.             XmlReader reader = null;
  302.             SchemaInfo xdrSchema = null;
  303.             try {
  304.                 Uri ruri = this.XmlResolver.ResolveUri(BaseUri, url);
  305.                 Stream stm = (Stream)this.XmlResolver.GetEntity(ruri, null, null);
  306.                 reader = new XmlTextReader(ruri.ToString(), stm, NameTable);
  307.                 ((XmlTextReader)reader).XmlResolver = this.XmlResolver;
  308.                 Parser parser = new Parser(SchemaType.XDR, NameTable, SchemaNames, EventHandler);
  309.                 parser.XmlResolver = this.XmlResolver;
  310.                 parser.Parse(reader, uri);
  311.                 while (reader.Read())
  312.                     ;
  313.                 // wellformness check
  314.                 xdrSchema = parser.XdrSchema;
  315.             }
  316.             catch (XmlSchemaException e) {
  317.                 SendValidationEvent(Res.Sch_CannotLoadSchema, new string[] {uri, e.Message}, XmlSeverityType.Error);
  318.             }
  319.             catch (Exception e) {
  320.                 SendValidationEvent(Res.Sch_CannotLoadSchema, new string[] {uri, e.Message}, XmlSeverityType.Warning);
  321.             }
  322.             finally {
  323.                 if (reader != null) {
  324.                     reader.Close();
  325.                 }
  326.             }
  327.             if (xdrSchema != null && xdrSchema.ErrorCount == 0) {
  328.                 schemaInfo.Add(xdrSchema, EventHandler);
  329.                 SchemaCollection.Add(uri, xdrSchema, null, false);
  330.             }
  331.         }
  332.        
  333.         private void LoadSchema(string uri)
  334.         {
  335.             if (SchemaInfo.TargetNamespaces.Contains(uri)) {
  336.                 return;
  337.             }
  338.             if (this.XmlResolver == null) {
  339.                 return;
  340.             }
  341.            
  342.             SchemaInfo schemaInfo = null;
  343.             if (SchemaCollection != null)
  344.                 schemaInfo = SchemaCollection.GetSchemaInfo(uri);
  345.             if (schemaInfo != null) {
  346.                 if (schemaInfo.SchemaType != SchemaType.XDR) {
  347.                     throw new XmlException(Res.Xml_MultipleValidaitonTypes, string.Empty, this.PositionInfo.LineNumber, this.PositionInfo.LinePosition);
  348.                 }
  349.                 SchemaInfo.Add(schemaInfo, EventHandler);
  350.                 return;
  351.             }
  352.             LoadSchemaFromLocation(uri);
  353.         }
  354.        
  355.         private bool HasSchema {
  356.             get { return schemaInfo.SchemaType != SchemaType.None; }
  357.         }
  358.        
  359.         public override bool PreserveWhitespace {
  360.             get { return context.ElementDecl != null ? context.ElementDecl.ContentValidator.PreserveWhitespace : false; }
  361.         }
  362.        
  363.         void ProcessTokenizedType(XmlTokenizedType ttype, string name)
  364.         {
  365.             switch (ttype) {
  366.                 case XmlTokenizedType.ID:
  367.                     if (FindId(name) != null) {
  368.                         SendValidationEvent(Res.Sch_DupId, name);
  369.                     }
  370.                     else {
  371.                         AddID(name, context.LocalName);
  372.                     }
  373.                     break;
  374.                 case XmlTokenizedType.IDREF:
  375.                     object p = FindId(name);
  376.                     if (p == null) {
  377.                         // add it to linked list to check it later
  378.                         idRefListHead = new IdRefNode(idRefListHead, name, this.PositionInfo.LineNumber, this.PositionInfo.LinePosition);
  379.                     }
  380.                     break;
  381.                 case XmlTokenizedType.ENTITY:
  382.                     ProcessEntity(schemaInfo, name, this, EventHandler, reader.BaseURI, PositionInfo.LineNumber, PositionInfo.LinePosition);
  383.                     break;
  384.                 default:
  385.                     break;
  386.             }
  387.         }
  388.        
  389.        
  390.         public override void CompleteValidation()
  391.         {
  392.             if (HasSchema) {
  393.                 CheckForwardRefs();
  394.             }
  395.             else {
  396.                 SendValidationEvent(new XmlSchemaException(Res.Xml_NoValidation, string.Empty), XmlSeverityType.Warning);
  397.             }
  398.         }
  399.        
  400.        
  401.         private void CheckValue(string value, SchemaAttDef attdef)
  402.         {
  403.             try {
  404.                 reader.TypedValueObject = null;
  405.                 bool isAttn = attdef != null;
  406.                 XmlSchemaDatatype dtype = isAttn ? attdef.Datatype : context.ElementDecl.Datatype;
  407.                 if (dtype == null) {
  408.                     return;
  409.                     // no reason to check
  410.                 }
  411.                
  412.                 if (dtype.TokenizedType != XmlTokenizedType.CDATA) {
  413.                     value = value.Trim();
  414.                 }
  415.                 if (value.Length == 0) {
  416.                     return;
  417.                     // don't need to check
  418.                 }
  419.                
  420.                
  421.                 object typedValue = dtype.ParseValue(value, NameTable, nsManager);
  422.                 reader.TypedValueObject = typedValue;
  423.                 // Check special types
  424.                 XmlTokenizedType ttype = dtype.TokenizedType;
  425.                 if (ttype == XmlTokenizedType.ENTITY || ttype == XmlTokenizedType.ID || ttype == XmlTokenizedType.IDREF) {
  426.                     if (dtype.Variety == XmlSchemaDatatypeVariety.List) {
  427.                         string[] ss = (string[])typedValue;
  428.                         foreach (string s in ss) {
  429.                             ProcessTokenizedType(dtype.TokenizedType, s);
  430.                         }
  431.                     }
  432.                     else {
  433.                         ProcessTokenizedType(dtype.TokenizedType, (string)typedValue);
  434.                     }
  435.                 }
  436.                
  437.                 SchemaDeclBase decl = isAttn ? (SchemaDeclBase)attdef : (SchemaDeclBase)context.ElementDecl;
  438.                
  439.                 if (decl.MaxLength != uint.MaxValue) {
  440.                     if (value.Length > decl.MaxLength) {
  441.                         SendValidationEvent(Res.Sch_MaxLengthConstraintFailed, value);
  442.                     }
  443.                 }
  444.                 if (decl.MinLength != uint.MaxValue) {
  445.                     if (value.Length < decl.MinLength) {
  446.                         SendValidationEvent(Res.Sch_MinLengthConstraintFailed, value);
  447.                     }
  448.                 }
  449.                 if (decl.Values != null && !decl.CheckEnumeration(typedValue)) {
  450.                     if (dtype.TokenizedType == XmlTokenizedType.NOTATION) {
  451.                         SendValidationEvent(Res.Sch_NotationValue, typedValue.ToString());
  452.                     }
  453.                     else {
  454.                         SendValidationEvent(Res.Sch_EnumerationValue, typedValue.ToString());
  455.                     }
  456.                    
  457.                 }
  458.                 if (!decl.CheckValue(typedValue)) {
  459.                     if (isAttn) {
  460.                         SendValidationEvent(Res.Sch_FixedAttributeValue, attdef.Name.ToString());
  461.                     }
  462.                     else {
  463.                         SendValidationEvent(Res.Sch_FixedElementValue, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
  464.                     }
  465.                 }
  466.             }
  467.             catch (XmlSchemaException) {
  468.                 if (attdef != null) {
  469.                     SendValidationEvent(Res.Sch_AttributeValueDataType, attdef.Name.ToString());
  470.                 }
  471.                 else {
  472.                     SendValidationEvent(Res.Sch_ElementValueDataType, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
  473.                 }
  474.             }
  475.         }
  476.        
  477.         public static void CheckDefaultValue(string value, SchemaAttDef attdef, SchemaInfo sinfo, XmlNamespaceManager nsManager, XmlNameTable NameTable, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNo, int linePos
  478.         )
  479.         {
  480.             try {
  481.                
  482.                 XmlSchemaDatatype dtype = attdef.Datatype;
  483.                 if (dtype == null) {
  484.                     return;
  485.                     // no reason to check
  486.                 }
  487.                
  488.                 if (dtype.TokenizedType != XmlTokenizedType.CDATA) {
  489.                     value = value.Trim();
  490.                 }
  491.                 if (value.Length == 0) {
  492.                     return;
  493.                     // don't need to check
  494.                 }
  495.                 object typedValue = dtype.ParseValue(value, NameTable, nsManager);
  496.                
  497.                 // Check special types
  498.                 XmlTokenizedType ttype = dtype.TokenizedType;
  499.                 if (ttype == XmlTokenizedType.ENTITY) {
  500.                     if (dtype.Variety == XmlSchemaDatatypeVariety.List) {
  501.                         string[] ss = (string[])typedValue;
  502.                         foreach (string s in ss) {
  503.                             ProcessEntity(sinfo, s, sender, eventhandler, baseUri, lineNo, linePos);
  504.                         }
  505.                     }
  506.                     else {
  507.                         ProcessEntity(sinfo, (string)typedValue, sender, eventhandler, baseUri, lineNo, linePos);
  508.                     }
  509.                 }
  510.                 else if (ttype == XmlTokenizedType.ENUMERATION) {
  511.                     if (!attdef.CheckEnumeration(typedValue)) {
  512.                         XmlSchemaException e = new XmlSchemaException(Res.Sch_EnumerationValue, typedValue.ToString(), baseUri, lineNo, linePos);
  513.                         if (eventhandler != null) {
  514.                             eventhandler(sender, new ValidationEventArgs(e));
  515.                         }
  516.                         else {
  517.                             throw e;
  518.                         }
  519.                     }
  520.                 }
  521.                 attdef.DefaultValueTyped = typedValue;
  522.             }
  523.             #if DEBUG
  524.             catch (XmlSchemaException ex) {
  525.                 Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message);
  526.             }
  527.             #else
  528.             catch {
  529.                 #endif
  530.                 XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString(), baseUri, lineNo, linePos);
  531.                 if (eventhandler != null) {
  532.                     eventhandler(sender, new ValidationEventArgs(e));
  533.                 }
  534.                 else {
  535.                     throw e;
  536.                 }
  537.             }
  538.         }
  539.        
  540.         internal void AddID(string name, object node)
  541.         {
  542.             // Note: It used to be true that we only called this if _fValidate was true,
  543.             // but due to the fact that you can now dynamically type somethign as an ID
  544.             // that is no longer true.
  545.             if (IDs == null) {
  546.                 IDs = new Hashtable();
  547.             }
  548.            
  549.             IDs.Add(name, node);
  550.         }
  551.        
  552.         public override object FindId(string name)
  553.         {
  554.             return IDs == null ? null : IDs[name];
  555.         }
  556.        
  557.         private void Push(XmlQualifiedName elementName)
  558.         {
  559.             context = (ValidationState)validationStack.Push();
  560.             if (context == null) {
  561.                 context = new ValidationState();
  562.                 validationStack.AddToTop(context);
  563.             }
  564.             context.LocalName = elementName.Name;
  565.             context.Namespace = elementName.Namespace;
  566.             context.HasMatched = false;
  567.             context.IsNill = false;
  568.             context.NeedValidateChildren = false;
  569.         }
  570.        
  571.         private void Pop()
  572.         {
  573.             if (validationStack.Length > 1) {
  574.                 validationStack.Pop();
  575.                 context = (ValidationState)validationStack.Peek();
  576.             }
  577.         }
  578.        
  579.         private void CheckForwardRefs()
  580.         {
  581.             IdRefNode next = idRefListHead;
  582.             while (next != null) {
  583.                 if (FindId(next.Id) == null) {
  584.                     SendValidationEvent(new XmlSchemaException(Res.Sch_UndeclaredId, next.Id, reader.BaseURI, next.LineNo, next.LinePos));
  585.                 }
  586.                 IdRefNode ptr = next.Next;
  587.                 next.Next = null;
  588.                 // unhook each object so it is cleaned up by Garbage Collector
  589.                 next = ptr;
  590.             }
  591.             // not needed any more.
  592.             idRefListHead = null;
  593.         }
  594.        
  595.         private XmlQualifiedName QualifiedName(string name, string ns)
  596.         {
  597.             return new XmlQualifiedName(name, XmlSchemaDatatype.XdrCanonizeUri(ns, NameTable, SchemaNames));
  598.         }
  599.        
  600.     }
  601.     #pragma warning restore 618
  602. }

Developer Fusion