The Labs \ Source Viewer \ SSCLI \ System.Xml \ XmlReaderSettings

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlReaderSettings.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. using System.Xml;
  16. using System.Xml.Schema;
  17. namespace System.Xml
  18. {
  19.    
  20.     // XmlReaderSettings class specifies features of an XmlReader.
  21.     public sealed class XmlReaderSettings
  22.     {
  23.         //
  24.         // Fields
  25.         //
  26.         // Nametable
  27.         XmlNameTable nameTable;
  28.        
  29.         // XmlResolver
  30.         XmlResolver xmlResolver;
  31.        
  32.         // Text settings
  33.         int lineNumberOffset;
  34.         int linePositionOffset;
  35.        
  36.         // Conformance settings
  37.         ConformanceLevel conformanceLevel;
  38.         bool checkCharacters;
  39.        
  40.         //Validation settings
  41.         ValidationType validationType;
  42.         XmlSchemaValidationFlags validationFlags;
  43.         XmlSchemaSet schemas;
  44.         ValidationEventHandler valEventHandler;
  45.        
  46.         // Filtering settings
  47.         bool ignoreWhitespace;
  48.         bool ignorePIs;
  49.         bool ignoreComments;
  50.        
  51.         // security settings
  52.         bool prohibitDtd;
  53.        
  54.         // other settings
  55.         bool closeInput;
  56.        
  57.         // read-only flag
  58.         bool isReadOnly;
  59.        
  60.         //
  61.         // Constructor
  62.         //
  63.         public XmlReaderSettings()
  64.         {
  65.             Reset();
  66.         }
  67.        
  68.         //
  69.         // Properties
  70.         //
  71.         // Nametable
  72.         public XmlNameTable NameTable {
  73.             get { return nameTable; }
  74.             set {
  75.                 CheckReadOnly("NameTable");
  76.                 nameTable = value;
  77.             }
  78.         }
  79.        
  80.         // XmlResolver
  81.         public XmlResolver XmlResolver {
  82.             set {
  83.                 CheckReadOnly("XmlResolver");
  84.                 xmlResolver = value;
  85.             }
  86.         }
  87.        
  88.         internal XmlResolver GetXmlResolver()
  89.         {
  90.             return xmlResolver;
  91.         }
  92.        
  93.         // Text settings
  94.         public int LineNumberOffset {
  95.             get { return lineNumberOffset; }
  96.             set {
  97.                 CheckReadOnly("LineNumberOffset");
  98.                 if (lineNumberOffset < 0) {
  99.                     throw new ArgumentOutOfRangeException("value");
  100.                 }
  101.                 lineNumberOffset = value;
  102.             }
  103.         }
  104.        
  105.         public int LinePositionOffset {
  106.             get { return linePositionOffset; }
  107.             set {
  108.                 CheckReadOnly("LinePositionOffset");
  109.                 if (linePositionOffset < 0) {
  110.                     throw new ArgumentOutOfRangeException("value");
  111.                 }
  112.                 linePositionOffset = value;
  113.             }
  114.         }
  115.        
  116.         // Conformance settings
  117.         public ConformanceLevel ConformanceLevel {
  118.             get { return conformanceLevel; }
  119.             set {
  120.                 CheckReadOnly("ConformanceLevel");
  121.                
  122.                 if ((uint)value > (uint)ConformanceLevel.Document) {
  123.                     throw new ArgumentOutOfRangeException("value");
  124.                 }
  125.                 conformanceLevel = value;
  126.             }
  127.         }
  128.        
  129.         public bool CheckCharacters {
  130.             get { return checkCharacters; }
  131.             set {
  132.                 CheckReadOnly("CheckCharacters");
  133.                 checkCharacters = value;
  134.             }
  135.         }
  136.        
  137.         public ValidationType ValidationType {
  138.             get { return validationType; }
  139.             set {
  140.                 CheckReadOnly("ValidationType");
  141.                
  142.                 if ((uint)value > (uint)ValidationType.Schema) {
  143.                     throw new ArgumentOutOfRangeException("value");
  144.                 }
  145.                 validationType = value;
  146.             }
  147.         }
  148.        
  149.         public XmlSchemaValidationFlags ValidationFlags {
  150.             get { return validationFlags; }
  151.             set {
  152.                 CheckReadOnly("ValidationFlags");
  153.                
  154.                 if ((uint)value > (uint)(XmlSchemaValidationFlags.ProcessInlineSchema | XmlSchemaValidationFlags.ProcessSchemaLocation | XmlSchemaValidationFlags.ReportValidationWarnings | XmlSchemaValidationFlags.ProcessIdentityConstraints | XmlSchemaValidationFlags.AllowXmlAttributes)) {
  155.                     throw new ArgumentOutOfRangeException("value");
  156.                 }
  157.                 validationFlags = value;
  158.             }
  159.         }
  160.        
  161.         public XmlSchemaSet Schemas {
  162.             get {
  163.                 if (schemas == null) {
  164.                     schemas = new XmlSchemaSet();
  165.                 }
  166.                 return schemas;
  167.             }
  168.             set {
  169.                 CheckReadOnly("Schemas");
  170.                 schemas = value;
  171.             }
  172.         }
  173.        
  174.         public event ValidationEventHandler ValidationEventHandler {
  175.             add {
  176.                 CheckReadOnly("ValidationEventHandler");
  177.                 valEventHandler += value;
  178.             }
  179.             remove {
  180.                 CheckReadOnly("ValidationEventHandler");
  181.                 valEventHandler -= value;
  182.             }
  183.         }
  184.        
  185.         // Filtering settings
  186.         public bool IgnoreWhitespace {
  187.             get { return ignoreWhitespace; }
  188.             set {
  189.                 CheckReadOnly("IgnoreWhitespace");
  190.                 ignoreWhitespace = value;
  191.             }
  192.         }
  193.        
  194.         public bool IgnoreProcessingInstructions {
  195.             get { return ignorePIs; }
  196.             set {
  197.                 CheckReadOnly("IgnoreProcessingInstructions");
  198.                 ignorePIs = value;
  199.             }
  200.         }
  201.        
  202.         public bool IgnoreComments {
  203.             get { return ignoreComments; }
  204.             set {
  205.                 CheckReadOnly("IgnoreComments");
  206.                 ignoreComments = value;
  207.             }
  208.         }
  209.        
  210.         public bool ProhibitDtd {
  211.             get { return prohibitDtd; }
  212.             set {
  213.                 CheckReadOnly("ProhibitDtd");
  214.                 prohibitDtd = value;
  215.             }
  216.         }
  217.        
  218.         public bool CloseInput {
  219.             get { return closeInput; }
  220.             set {
  221.                 CheckReadOnly("CloseInput");
  222.                 closeInput = value;
  223.             }
  224.         }
  225.        
  226.         //
  227.         // Public methods
  228.         //
  229.         public void Reset()
  230.         {
  231.             CheckReadOnly("Reset");
  232.            
  233.             nameTable = null;
  234.             xmlResolver = new XmlUrlResolver();
  235.             lineNumberOffset = 0;
  236.             linePositionOffset = 0;
  237.             checkCharacters = true;
  238.             conformanceLevel = ConformanceLevel.Document;
  239.            
  240.             schemas = null;
  241.             validationType = ValidationType.None;
  242.             validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints;
  243.             validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;
  244.             ignoreWhitespace = false;
  245.             ignorePIs = false;
  246.             ignoreComments = false;
  247.             prohibitDtd = true;
  248.             closeInput = false;
  249.            
  250.             isReadOnly = false;
  251.         }
  252.        
  253.         public XmlReaderSettings Clone()
  254.         {
  255.             XmlReaderSettings clonedSettings = MemberwiseClone() as XmlReaderSettings;
  256.             clonedSettings.isReadOnly = false;
  257.             return clonedSettings;
  258.         }
  259.        
  260.         //
  261.         // Internal and private methods
  262.         //
  263.         internal bool ReadOnly {
  264.             get { return isReadOnly; }
  265.             set { isReadOnly = value; }
  266.         }
  267.        
  268.         internal ValidationEventHandler GetEventHandler()
  269.         {
  270.             return valEventHandler;
  271.         }
  272.        
  273.         private void CheckReadOnly(string propertyName)
  274.         {
  275.             if (isReadOnly) {
  276.                 throw new XmlException(Res.Xml_ReadOnlyProperty, "XmlReaderSettings." + propertyName);
  277.             }
  278.         }
  279.        
  280.         internal bool CanResolveExternals {
  281.             get { return prohibitDtd == false && xmlResolver != null; }
  282.         }
  283.        
  284.     }
  285. }

Developer Fusion