Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Xml / System / Xml / Core / XmlCharCheckingReader.cs / 1 / XmlCharCheckingReader.cs
//------------------------------------------------------------------------------ //// Copyright (c) Microsoft Corporation. All rights reserved. // //[....] //----------------------------------------------------------------------------- using System; using System.Xml; using System.Xml.XPath; using System.Diagnostics; using System.Collections; using System.Collections.Generic; namespace System.Xml { // // XmlCharCheckingReaderWithNS // internal class XmlCharCheckingReader : XmlWrappingReader { // // Private types // enum State { Initial, InReadBinary, Error, Interactive, // Interactive means other than ReadState.Initial and ReadState.Error; still needs to call // underlying XmlReader to find out if the reported ReadState should be Interactive, EndOfFile or Closed }; // // Fields // State state; // settings bool checkCharacters; bool ignoreWhitespace; bool ignoreComments; bool ignorePis; bool prohibitDtd; XmlNodeType lastNodeType; XmlCharType xmlCharType; ReadContentAsBinaryHelper readBinaryHelper; // // Constructor // internal XmlCharCheckingReader( XmlReader reader, bool checkCharacters, bool ignoreWhitespace, bool ignoreComments, bool ignorePis, bool prohibitDtd ) : base( reader ) { Debug.Assert( checkCharacters || ignoreWhitespace || ignoreComments || ignorePis || prohibitDtd ); state = State.Initial; this.checkCharacters = checkCharacters; this.ignoreWhitespace = ignoreWhitespace; this.ignoreComments = ignoreComments; this.ignorePis = ignorePis; this.prohibitDtd = prohibitDtd; lastNodeType = XmlNodeType.None; if ( checkCharacters ) { xmlCharType = XmlCharType.Instance; } } // // XmlReader implementation // public override XmlReaderSettings Settings { get { XmlReaderSettings settings = reader.Settings; if ( settings == null ) { settings = new XmlReaderSettings(); } else { settings = settings.Clone(); } if ( checkCharacters ) { settings.CheckCharacters = true; } if ( ignoreWhitespace ) { settings.IgnoreWhitespace = true; } if ( ignoreComments ) { settings.IgnoreComments = true; } if ( ignorePis ) { settings.IgnoreProcessingInstructions = true; } if ( prohibitDtd ) { settings.ProhibitDtd = true; } settings.ReadOnly = true; return settings; } } public override bool MoveToAttribute( string name ) { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToAttribute( name ); } public override bool MoveToAttribute( string name, string ns ) { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToAttribute( name, ns ); } public override void MoveToAttribute( int i ) { if ( state == State.InReadBinary ) { FinishReadBinary(); } base.reader.MoveToAttribute( i ); } public override bool MoveToFirstAttribute() { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToFirstAttribute(); } public override bool MoveToNextAttribute() { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToNextAttribute(); } public override bool MoveToElement() { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToElement(); } public override bool Read() { switch ( state ) { case State.Initial: state = State.Interactive; if ( base.reader.ReadState == ReadState.Initial ) { goto case State.Interactive; } break; case State.Error: return false; case State.InReadBinary: FinishReadBinary(); state = State.Interactive; goto case State.Interactive; case State.Interactive: if ( !base.reader.Read() ) { return false; } break; default: Debug.Assert( false ); return false; } XmlNodeType nodeType = base.reader.NodeType; if ( !checkCharacters ) { switch ( nodeType ) { case XmlNodeType.Comment: if ( ignoreComments ) { return Read(); } break; case XmlNodeType.Whitespace: if ( ignoreWhitespace ) { return Read(); } break; case XmlNodeType.ProcessingInstruction: if ( ignorePis ) { return Read(); } break; case XmlNodeType.DocumentType: if ( prohibitDtd ) { Throw( Res.Xml_DtdIsProhibited, string.Empty ); } break; } return true; } else { switch ( nodeType ) { case XmlNodeType.Element: if ( checkCharacters ) { // check element name ValidateQName( base.reader.Prefix, base.reader.LocalName ); // check values of attributes if ( base.reader.MoveToFirstAttribute() ) { do { ValidateQName( base.reader.Prefix, base.reader.LocalName ); CheckCharacters( base.reader.Value ); } while ( base.reader.MoveToNextAttribute() ); base.reader.MoveToElement(); } } break; case XmlNodeType.Text: case XmlNodeType.CDATA: if ( checkCharacters ) { CheckCharacters( base.reader.Value ); } break; case XmlNodeType.EntityReference: if ( checkCharacters ) { // check name ValidateQName( base.reader.Name ); } break; case XmlNodeType.ProcessingInstruction: if ( ignorePis ) { return Read(); } if ( checkCharacters ) { ValidateQName( base.reader.Name ); CheckCharacters( base.reader.Value ); } break; case XmlNodeType.Comment: if ( ignoreComments ) { return Read(); } if ( checkCharacters ) { CheckCharacters( base.reader.Value ); } break; case XmlNodeType.DocumentType: if ( prohibitDtd ) { Throw( Res.Xml_DtdIsProhibited, string.Empty ); } if ( checkCharacters ) { ValidateQName( base.reader.Name ); CheckCharacters( base.reader.Value ); string str; str = base.reader.GetAttribute( "SYSTEM" ); if ( str != null ) { CheckCharacters( str ); } str = base.reader.GetAttribute( "PUBLIC" ); if ( str != null ) { int i; if ( ( i = xmlCharType.IsPublicId( str ) ) >= 0 ) { Throw( Res.Xml_InvalidCharacter, XmlException.BuildCharExceptionStr( str[i] ) ); } } } break; case XmlNodeType.Whitespace: if ( ignoreWhitespace ) { return Read(); } if ( checkCharacters ) { CheckWhitespace( base.reader.Value ); } break; case XmlNodeType.SignificantWhitespace: if ( checkCharacters ) { CheckWhitespace( base.reader.Value ); } break; case XmlNodeType.EndElement: if ( checkCharacters ) { ValidateQName( base.reader.Prefix, base.reader.LocalName ); } break; default: break; } lastNodeType = nodeType; return true; } } public override ReadState ReadState { get { switch ( state ) { case State.Initial: return ReadState.Initial; case State.Error: return ReadState.Error; case State.InReadBinary: case State.Interactive: default: return base.reader.ReadState; } } } public override void ResolveEntity() { base.reader.ResolveEntity(); } public override bool ReadAttributeValue() { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.ReadAttributeValue(); } public override bool CanReadBinaryContent { get { return true; } } public override int ReadContentAsBase64( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBase64Chunk calls into the base (wrapped) reader if possible, i.e. if it can read binary and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadContentAsBase64( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadContentAsBase64( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadContentAsBase64(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; } public override int ReadContentAsBinHex( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadContentAsBinHex( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadContentAsBinHex( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadContentAsBinHex(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; } public override int ReadElementContentAsBase64( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBase64Chunk calls into the base (wrapped) reader if possible, i.e. if it can read binary and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadElementContentAsBase64( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadElementContentAsBase64( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBase64(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; } public override int ReadElementContentAsBinHex( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadElementContentAsBinHex( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadElementContentAsBinHex( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; } // // Private methods and properties // private void Throw( string res, string arg ) { state = State.Error; throw new XmlException( res, arg, (IXmlLineInfo)null ); } private void Throw( string res, string[] args ) { state = State.Error; throw new XmlException( res, args, (IXmlLineInfo)null ); } private void CheckWhitespace( string value ) { int i; if ( ( i = xmlCharType.IsOnlyWhitespaceWithPos( value ) ) != -1 ) { Throw( Res.Xml_InvalidWhitespaceCharacter, XmlException.BuildCharExceptionStr( base.reader.Value[i] ) ); } } private void ValidateQName( string name ) { string prefix, localName; ValidateNames.ParseQNameThrow( name, out prefix, out localName ); } private void ValidateQName( string prefix, string localName ) { try { if ( prefix.Length > 0 ) { ValidateNames.ParseNCNameThrow( prefix ); } ValidateNames.ParseNCNameThrow( localName ); } catch { state = State.Error; throw; } } private void CheckCharacters( string value ) { XmlConvert.VerifyCharData( value, ExceptionType.XmlException ); } private void FinishReadBinary() { state = State.Interactive; if ( readBinaryHelper != null ) { readBinaryHelper.Finish(); } } } // // XmlCharCheckingReaderWithNS // internal class XmlCharCheckingReaderWithNS : XmlCharCheckingReader, IXmlNamespaceResolver { internal IXmlNamespaceResolver readerAsNSResolver; internal XmlCharCheckingReaderWithNS( XmlReader reader, IXmlNamespaceResolver readerAsNSResolver, bool checkCharacters, bool ignoreWhitespace, bool ignoreComments, bool ignorePis, bool prohibitDtd ) : base( reader, checkCharacters, ignoreWhitespace, ignoreComments, ignorePis, prohibitDtd ) { Debug.Assert( readerAsNSResolver != null ); this.readerAsNSResolver = readerAsNSResolver; } // // IXmlNamespaceResolver // IDictionaryIXmlNamespaceResolver.GetNamespacesInScope( XmlNamespaceScope scope ) { return readerAsNSResolver.GetNamespacesInScope( scope ); } string IXmlNamespaceResolver.LookupNamespace( string prefix ) { return readerAsNSResolver.LookupNamespace( prefix ); } string IXmlNamespaceResolver.LookupPrefix( string namespaceName ) { return readerAsNSResolver.LookupPrefix( namespaceName ); } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. //------------------------------------------------------------------------------ // // Copyright (c) Microsoft Corporation. All rights reserved. // //[....] //----------------------------------------------------------------------------- using System; using System.Xml; using System.Xml.XPath; using System.Diagnostics; using System.Collections; using System.Collections.Generic; namespace System.Xml { // // XmlCharCheckingReaderWithNS // internal class XmlCharCheckingReader : XmlWrappingReader { // // Private types // enum State { Initial, InReadBinary, Error, Interactive, // Interactive means other than ReadState.Initial and ReadState.Error; still needs to call // underlying XmlReader to find out if the reported ReadState should be Interactive, EndOfFile or Closed }; // // Fields // State state; // settings bool checkCharacters; bool ignoreWhitespace; bool ignoreComments; bool ignorePis; bool prohibitDtd; XmlNodeType lastNodeType; XmlCharType xmlCharType; ReadContentAsBinaryHelper readBinaryHelper; // // Constructor // internal XmlCharCheckingReader( XmlReader reader, bool checkCharacters, bool ignoreWhitespace, bool ignoreComments, bool ignorePis, bool prohibitDtd ) : base( reader ) { Debug.Assert( checkCharacters || ignoreWhitespace || ignoreComments || ignorePis || prohibitDtd ); state = State.Initial; this.checkCharacters = checkCharacters; this.ignoreWhitespace = ignoreWhitespace; this.ignoreComments = ignoreComments; this.ignorePis = ignorePis; this.prohibitDtd = prohibitDtd; lastNodeType = XmlNodeType.None; if ( checkCharacters ) { xmlCharType = XmlCharType.Instance; } } // // XmlReader implementation // public override XmlReaderSettings Settings { get { XmlReaderSettings settings = reader.Settings; if ( settings == null ) { settings = new XmlReaderSettings(); } else { settings = settings.Clone(); } if ( checkCharacters ) { settings.CheckCharacters = true; } if ( ignoreWhitespace ) { settings.IgnoreWhitespace = true; } if ( ignoreComments ) { settings.IgnoreComments = true; } if ( ignorePis ) { settings.IgnoreProcessingInstructions = true; } if ( prohibitDtd ) { settings.ProhibitDtd = true; } settings.ReadOnly = true; return settings; } } public override bool MoveToAttribute( string name ) { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToAttribute( name ); } public override bool MoveToAttribute( string name, string ns ) { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToAttribute( name, ns ); } public override void MoveToAttribute( int i ) { if ( state == State.InReadBinary ) { FinishReadBinary(); } base.reader.MoveToAttribute( i ); } public override bool MoveToFirstAttribute() { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToFirstAttribute(); } public override bool MoveToNextAttribute() { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToNextAttribute(); } public override bool MoveToElement() { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.MoveToElement(); } public override bool Read() { switch ( state ) { case State.Initial: state = State.Interactive; if ( base.reader.ReadState == ReadState.Initial ) { goto case State.Interactive; } break; case State.Error: return false; case State.InReadBinary: FinishReadBinary(); state = State.Interactive; goto case State.Interactive; case State.Interactive: if ( !base.reader.Read() ) { return false; } break; default: Debug.Assert( false ); return false; } XmlNodeType nodeType = base.reader.NodeType; if ( !checkCharacters ) { switch ( nodeType ) { case XmlNodeType.Comment: if ( ignoreComments ) { return Read(); } break; case XmlNodeType.Whitespace: if ( ignoreWhitespace ) { return Read(); } break; case XmlNodeType.ProcessingInstruction: if ( ignorePis ) { return Read(); } break; case XmlNodeType.DocumentType: if ( prohibitDtd ) { Throw( Res.Xml_DtdIsProhibited, string.Empty ); } break; } return true; } else { switch ( nodeType ) { case XmlNodeType.Element: if ( checkCharacters ) { // check element name ValidateQName( base.reader.Prefix, base.reader.LocalName ); // check values of attributes if ( base.reader.MoveToFirstAttribute() ) { do { ValidateQName( base.reader.Prefix, base.reader.LocalName ); CheckCharacters( base.reader.Value ); } while ( base.reader.MoveToNextAttribute() ); base.reader.MoveToElement(); } } break; case XmlNodeType.Text: case XmlNodeType.CDATA: if ( checkCharacters ) { CheckCharacters( base.reader.Value ); } break; case XmlNodeType.EntityReference: if ( checkCharacters ) { // check name ValidateQName( base.reader.Name ); } break; case XmlNodeType.ProcessingInstruction: if ( ignorePis ) { return Read(); } if ( checkCharacters ) { ValidateQName( base.reader.Name ); CheckCharacters( base.reader.Value ); } break; case XmlNodeType.Comment: if ( ignoreComments ) { return Read(); } if ( checkCharacters ) { CheckCharacters( base.reader.Value ); } break; case XmlNodeType.DocumentType: if ( prohibitDtd ) { Throw( Res.Xml_DtdIsProhibited, string.Empty ); } if ( checkCharacters ) { ValidateQName( base.reader.Name ); CheckCharacters( base.reader.Value ); string str; str = base.reader.GetAttribute( "SYSTEM" ); if ( str != null ) { CheckCharacters( str ); } str = base.reader.GetAttribute( "PUBLIC" ); if ( str != null ) { int i; if ( ( i = xmlCharType.IsPublicId( str ) ) >= 0 ) { Throw( Res.Xml_InvalidCharacter, XmlException.BuildCharExceptionStr( str[i] ) ); } } } break; case XmlNodeType.Whitespace: if ( ignoreWhitespace ) { return Read(); } if ( checkCharacters ) { CheckWhitespace( base.reader.Value ); } break; case XmlNodeType.SignificantWhitespace: if ( checkCharacters ) { CheckWhitespace( base.reader.Value ); } break; case XmlNodeType.EndElement: if ( checkCharacters ) { ValidateQName( base.reader.Prefix, base.reader.LocalName ); } break; default: break; } lastNodeType = nodeType; return true; } } public override ReadState ReadState { get { switch ( state ) { case State.Initial: return ReadState.Initial; case State.Error: return ReadState.Error; case State.InReadBinary: case State.Interactive: default: return base.reader.ReadState; } } } public override void ResolveEntity() { base.reader.ResolveEntity(); } public override bool ReadAttributeValue() { if ( state == State.InReadBinary ) { FinishReadBinary(); } return base.reader.ReadAttributeValue(); } public override bool CanReadBinaryContent { get { return true; } } public override int ReadContentAsBase64( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBase64Chunk calls into the base (wrapped) reader if possible, i.e. if it can read binary and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadContentAsBase64( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadContentAsBase64( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadContentAsBase64(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; } public override int ReadContentAsBinHex( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadContentAsBinHex( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadContentAsBinHex( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadContentAsBinHex(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; } public override int ReadElementContentAsBase64( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBase64Chunk calls into the base (wrapped) reader if possible, i.e. if it can read binary and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadElementContentAsBase64( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadElementContentAsBase64( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBase64(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; } public override int ReadElementContentAsBinHex( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadElementContentAsBinHex( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadElementContentAsBinHex( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; } // // Private methods and properties // private void Throw( string res, string arg ) { state = State.Error; throw new XmlException( res, arg, (IXmlLineInfo)null ); } private void Throw( string res, string[] args ) { state = State.Error; throw new XmlException( res, args, (IXmlLineInfo)null ); } private void CheckWhitespace( string value ) { int i; if ( ( i = xmlCharType.IsOnlyWhitespaceWithPos( value ) ) != -1 ) { Throw( Res.Xml_InvalidWhitespaceCharacter, XmlException.BuildCharExceptionStr( base.reader.Value[i] ) ); } } private void ValidateQName( string name ) { string prefix, localName; ValidateNames.ParseQNameThrow( name, out prefix, out localName ); } private void ValidateQName( string prefix, string localName ) { try { if ( prefix.Length > 0 ) { ValidateNames.ParseNCNameThrow( prefix ); } ValidateNames.ParseNCNameThrow( localName ); } catch { state = State.Error; throw; } } private void CheckCharacters( string value ) { XmlConvert.VerifyCharData( value, ExceptionType.XmlException ); } private void FinishReadBinary() { state = State.Interactive; if ( readBinaryHelper != null ) { readBinaryHelper.Finish(); } } } // // XmlCharCheckingReaderWithNS // internal class XmlCharCheckingReaderWithNS : XmlCharCheckingReader, IXmlNamespaceResolver { internal IXmlNamespaceResolver readerAsNSResolver; internal XmlCharCheckingReaderWithNS( XmlReader reader, IXmlNamespaceResolver readerAsNSResolver, bool checkCharacters, bool ignoreWhitespace, bool ignoreComments, bool ignorePis, bool prohibitDtd ) : base( reader, checkCharacters, ignoreWhitespace, ignoreComments, ignorePis, prohibitDtd ) { Debug.Assert( readerAsNSResolver != null ); this.readerAsNSResolver = readerAsNSResolver; } // // IXmlNamespaceResolver // IDictionaryIXmlNamespaceResolver.GetNamespacesInScope( XmlNamespaceScope scope ) { return readerAsNSResolver.GetNamespacesInScope( scope ); } string IXmlNamespaceResolver.LookupNamespace( string prefix ) { return readerAsNSResolver.LookupNamespace( prefix ); } string IXmlNamespaceResolver.LookupPrefix( string namespaceName ) { return readerAsNSResolver.LookupPrefix( namespaceName ); } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- TextTabProperties.cs
- DataMemberConverter.cs
- Serializer.cs
- SignedXml.cs
- Converter.cs
- CodeBlockBuilder.cs
- Permission.cs
- AppDomainEvidenceFactory.cs
- WebWorkflowRole.cs
- XmlQueryTypeFactory.cs
- BindingCompleteEventArgs.cs
- WebBrowserUriTypeConverter.cs
- ImmComposition.cs
- SmtpTransport.cs
- HttpDebugHandler.cs
- TypeInitializationException.cs
- PropertyPath.cs
- HiddenFieldPageStatePersister.cs
- ActionNotSupportedException.cs
- Facet.cs
- CreateUserErrorEventArgs.cs
- DetailsViewInsertEventArgs.cs
- CodeAttachEventStatement.cs
- DataTransferEventArgs.cs
- LightweightCodeGenerator.cs
- RowSpanVector.cs
- LogManagementAsyncResult.cs
- COM2ComponentEditor.cs
- BitmapCacheBrush.cs
- WrappedReader.cs
- Debug.cs
- NativeStructs.cs
- PageVisual.cs
- GrammarBuilderWildcard.cs
- Line.cs
- CategoryValueConverter.cs
- VisualCollection.cs
- NameValueConfigurationElement.cs
- TransformGroup.cs
- SiteOfOriginContainer.cs
- FloaterParaClient.cs
- DataGridViewRowHeaderCell.cs
- WebPermission.cs
- DeferredBinaryDeserializerExtension.cs
- FileRecordSequenceCompletedAsyncResult.cs
- XmlJsonReader.cs
- CompilerInfo.cs
- DSASignatureDeformatter.cs
- CompilerGeneratedAttribute.cs
- Int32Rect.cs
- ValidationUtility.cs
- DesigntimeLicenseContextSerializer.cs
- FixedTextView.cs
- FrameSecurityDescriptor.cs
- ColorMatrix.cs
- DebugView.cs
- PieceDirectory.cs
- StoreAnnotationsMap.cs
- _RegBlobWebProxyDataBuilder.cs
- InstallHelper.cs
- QueryExpression.cs
- NavigatorInput.cs
- PaperSource.cs
- WebPartVerb.cs
- ImageMetadata.cs
- SchemaCollectionCompiler.cs
- Gdiplus.cs
- StylusPointPropertyId.cs
- SynchronizationContext.cs
- DataGridTextBox.cs
- DeferredSelectedIndexReference.cs
- UnsafePeerToPeerMethods.cs
- ExternalException.cs
- _LoggingObject.cs
- FileDataSourceCache.cs
- BitmapCache.cs
- SymbolMethod.cs
- Attributes.cs
- Serializer.cs
- TypeSystemHelpers.cs
- DataProviderNameConverter.cs
- AbandonedMutexException.cs
- HttpBufferlessInputStream.cs
- StorageModelBuildProvider.cs
- localization.cs
- LogicalTreeHelper.cs
- TraceLog.cs
- COM2PropertyDescriptor.cs
- WindowsGrip.cs
- XPathAncestorQuery.cs
- FormattedText.cs
- ToggleButton.cs
- QueryGenerator.cs
- HttpCapabilitiesBase.cs
- ImageConverter.cs
- ClientScriptManager.cs
- DtdParser.cs
- WaitHandleCannotBeOpenedException.cs
- NetTcpBindingElement.cs
- ProxySimple.cs