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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlValidatingReader.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;
  16. using System.IO;
  17. using System.Text;
  18. using System.Xml.Schema;
  19. using System.Collections;
  20. using System.Collections.Generic;
  21. using System.Security.Permissions;
  22. namespace System.Xml
  23. {
  24.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  25.     [Obsolete("Use XmlReader created by XmlReader.Create() method using appropriate XmlReaderSettings instead. http://go.microsoft.com/fwlink/?linkid=14202")]
  26.     public class XmlValidatingReader : XmlReader, IXmlLineInfo, IXmlNamespaceResolver
  27.     {
  28.         //
  29.         // Member fields
  30.         //
  31.         XmlValidatingReaderImpl impl;
  32.         //
  33.         // Constructors
  34.         //
  35.         public XmlValidatingReader(XmlReader reader)
  36.         {
  37.             impl = new XmlValidatingReaderImpl(reader);
  38.             impl.OuterReader = this;
  39.         }
  40.        
  41.         public XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
  42.         {
  43.             impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context);
  44.             impl.OuterReader = this;
  45.         }
  46.        
  47.         public XmlValidatingReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
  48.         {
  49.             impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context);
  50.             impl.OuterReader = this;
  51.         }
  52.        
  53.         //
  54.         // XmlReader members
  55.         //
  56.         public override XmlReaderSettings Settings {
  57.             get { return null; }
  58.         }
  59.        
  60.         public override XmlNodeType NodeType {
  61.             get { return impl.NodeType; }
  62.         }
  63.        
  64.         public override string Name {
  65.             get { return impl.Name; }
  66.         }
  67.        
  68.         public override string LocalName {
  69.             get { return impl.LocalName; }
  70.         }
  71.        
  72.         public override string NamespaceURI {
  73.             get { return impl.NamespaceURI; }
  74.         }
  75.        
  76.         public override string Prefix {
  77.             get { return impl.Prefix; }
  78.         }
  79.        
  80.         public override bool HasValue {
  81.             get { return impl.HasValue; }
  82.         }
  83.        
  84.         public override string Value {
  85.             get { return impl.Value; }
  86.         }
  87.        
  88.         public override int Depth {
  89.             get { return impl.Depth; }
  90.         }
  91.        
  92.         public override string BaseURI {
  93.             get { return impl.BaseURI; }
  94.         }
  95.        
  96.         public override bool IsEmptyElement {
  97.             get { return impl.IsEmptyElement; }
  98.         }
  99.        
  100.         public override bool IsDefault {
  101.             get { return impl.IsDefault; }
  102.         }
  103.        
  104.         public override char QuoteChar {
  105.             get { return impl.QuoteChar; }
  106.         }
  107.        
  108.         public override XmlSpace XmlSpace {
  109.             get { return impl.XmlSpace; }
  110.         }
  111.        
  112.         public override string XmlLang {
  113.             get { return impl.XmlLang; }
  114.         }
  115.        
  116.         // XmlTextReader does not override SchemaInfo, ValueType and ReadTypeValue
  117.        
  118.         public override int AttributeCount {
  119.             get { return impl.AttributeCount; }
  120.         }
  121.        
  122.         public override string GetAttribute(string name)
  123.         {
  124.             return impl.GetAttribute(name);
  125.         }
  126.        
  127.         public override string GetAttribute(string localName, string namespaceURI)
  128.         {
  129.             return impl.GetAttribute(localName, namespaceURI);
  130.         }
  131.        
  132.         public override string GetAttribute(int i)
  133.         {
  134.             return impl.GetAttribute(i);
  135.         }
  136.        
  137.         public override bool MoveToAttribute(string name)
  138.         {
  139.             return impl.MoveToAttribute(name);
  140.         }
  141.        
  142.         public override bool MoveToAttribute(string localName, string namespaceURI)
  143.         {
  144.             return impl.MoveToAttribute(localName, namespaceURI);
  145.         }
  146.        
  147.         public override void MoveToAttribute(int i)
  148.         {
  149.             impl.MoveToAttribute(i);
  150.         }
  151.        
  152.         public override bool MoveToFirstAttribute()
  153.         {
  154.             return impl.MoveToFirstAttribute();
  155.         }
  156.        
  157.         public override bool MoveToNextAttribute()
  158.         {
  159.             return impl.MoveToNextAttribute();
  160.         }
  161.        
  162.         public override bool MoveToElement()
  163.         {
  164.             return impl.MoveToElement();
  165.         }
  166.        
  167.         public override bool ReadAttributeValue()
  168.         {
  169.             return impl.ReadAttributeValue();
  170.         }
  171.        
  172.         public override bool Read()
  173.         {
  174.             return impl.Read();
  175.         }
  176.        
  177.         public override bool EOF {
  178.             get { return impl.EOF; }
  179.         }
  180.        
  181.         public override void Close()
  182.         {
  183.             impl.Close();
  184.         }
  185.        
  186.         public override ReadState ReadState {
  187.             get { return impl.ReadState; }
  188.         }
  189.        
  190.         public override XmlNameTable NameTable {
  191.             get { return impl.NameTable; }
  192.         }
  193.        
  194.         public override string LookupNamespace(string prefix)
  195.         {
  196.             string ns = impl.LookupNamespace(prefix);
  197.             if (ns != null && ns.Length == 0) {
  198.                 ns = null;
  199.             }
  200.             return ns;
  201.         }
  202.        
  203.         public override bool CanResolveEntity {
  204.             get { return true; }
  205.         }
  206.        
  207.         public override void ResolveEntity()
  208.         {
  209.             impl.ResolveEntity();
  210.         }
  211.        
  212.         // Binary content access methods
  213.         public override bool CanReadBinaryContent {
  214.             get { return true; }
  215.         }
  216.        
  217.         public override int ReadContentAsBase64(byte[] buffer, int index, int count)
  218.         {
  219.             return impl.ReadContentAsBase64(buffer, index, count);
  220.         }
  221.        
  222.         public override int ReadElementContentAsBase64(byte[] buffer, int index, int count)
  223.         {
  224.             return impl.ReadElementContentAsBase64(buffer, index, count);
  225.         }
  226.        
  227.         public override int ReadContentAsBinHex(byte[] buffer, int index, int count)
  228.         {
  229.             return impl.ReadContentAsBinHex(buffer, index, count);
  230.         }
  231.        
  232.         public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count)
  233.         {
  234.             return impl.ReadElementContentAsBinHex(buffer, index, count);
  235.         }
  236.        
  237.         // Overriden helper methods
  238.        
  239.         public override string ReadString()
  240.         {
  241.             impl.MoveOffEntityReference();
  242.             return base.ReadString();
  243.         }
  244.        
  245.         //
  246.         // IXmlLineInfo members
  247.         //
  248.         public bool HasLineInfo()
  249.         {
  250.             return true;
  251.         }
  252.        
  253.         public int LineNumber {
  254.             get { return impl.LineNumber; }
  255.         }
  256.        
  257.         public int LinePosition {
  258.             get { return impl.LinePosition; }
  259.         }
  260.        
  261.         //
  262.         // IXmlNamespaceResolver members
  263.         //
  264.         IDictionary<string, string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope)
  265.         {
  266.             return impl.GetNamespacesInScope(scope);
  267.         }
  268.        
  269.         string IXmlNamespaceResolver.LookupNamespace(string prefix)
  270.         {
  271.             return impl.LookupNamespace(prefix);
  272.         }
  273.        
  274.         string IXmlNamespaceResolver.LookupPrefix(string namespaceName)
  275.         {
  276.             return impl.LookupPrefix(namespaceName);
  277.         }
  278.        
  279.         //
  280.         // XmlValidatingReader
  281.         //
  282.         public event ValidationEventHandler ValidationEventHandler {
  283.             add { impl.ValidationEventHandler += value; }
  284.             remove { impl.ValidationEventHandler -= value; }
  285.         }
  286.        
  287.         public object SchemaType {
  288.             get { return impl.SchemaType; }
  289.         }
  290.        
  291.         public XmlReader Reader {
  292.             get { return impl.Reader; }
  293.         }
  294.        
  295.         public ValidationType ValidationType {
  296.             get { return impl.ValidationType; }
  297.             set { impl.ValidationType = value; }
  298.         }
  299.        
  300.         public XmlSchemaCollection Schemas {
  301.             get { return impl.Schemas; }
  302.         }
  303.        
  304.         public EntityHandling EntityHandling {
  305.             get { return impl.EntityHandling; }
  306.             set { impl.EntityHandling = value; }
  307.         }
  308.        
  309.         public XmlResolver XmlResolver {
  310.             set { impl.XmlResolver = value; }
  311.         }
  312.        
  313.         public bool Namespaces {
  314.             get { return impl.Namespaces; }
  315.             set { impl.Namespaces = value; }
  316.         }
  317.        
  318.         public object ReadTypedValue()
  319.         {
  320.             return impl.ReadTypedValue();
  321.         }
  322.        
  323.         public Encoding Encoding {
  324.             get { return impl.Encoding; }
  325.         }
  326.         //
  327.         // Internal helper methods
  328.         //
  329.         internal XmlValidatingReaderImpl Impl {
  330.             get { return impl; }
  331.         }
  332.     }
  333. }

Developer Fusion