Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Xml / System / Xml / Core / XmlReaderSettings.cs / 1305376 / XmlReaderSettings.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
using System.IO;
using System.Diagnostics;
using System.Security.Permissions;
#if !SILVERLIGHT
using System.Xml.Schema;
#endif
using System.Runtime.Versioning;
namespace System.Xml {
// XmlReaderSettings class specifies basic features of an XmlReader.
#if !SILVERLIGHT
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
#endif
public sealed class XmlReaderSettings {
//
// Fields
//
// Nametable
XmlNameTable nameTable;
// XmlResolver
XmlResolver xmlResolver;
// Text settings
int lineNumberOffset;
int linePositionOffset;
// Conformance settings
ConformanceLevel conformanceLevel;
bool checkCharacters;
long maxCharactersInDocument;
long maxCharactersFromEntities;
// Filtering settings
bool ignoreWhitespace;
bool ignorePIs;
bool ignoreComments;
// security settings
DtdProcessing dtdProcessing;
#if !SILVERLIGHT
//Validation settings
ValidationType validationType;
XmlSchemaValidationFlags validationFlags;
XmlSchemaSet schemas;
ValidationEventHandler valEventHandler;
#endif
// other settings
bool closeInput;
// read-only flag
bool isReadOnly;
//
// Constructor
//
public XmlReaderSettings() {
Initialize();
}
//
// Properties
//
// Nametable
public XmlNameTable NameTable {
get {
return nameTable;
}
set {
CheckReadOnly("NameTable");
nameTable = value;
}
}
// XmlResolver
public XmlResolver XmlResolver {
set {
CheckReadOnly("XmlResolver");
xmlResolver = value;
}
}
internal XmlResolver GetXmlResolver() {
return xmlResolver;
}
// Text settings
public int LineNumberOffset {
get {
return lineNumberOffset;
}
set {
CheckReadOnly("LineNumberOffset");
lineNumberOffset = value;
}
}
public int LinePositionOffset {
get {
return linePositionOffset;
}
set {
CheckReadOnly("LinePositionOffset");
linePositionOffset = value;
}
}
// Conformance settings
public ConformanceLevel ConformanceLevel {
get {
return conformanceLevel;
}
set {
CheckReadOnly("ConformanceLevel");
if ((uint)value > (uint)ConformanceLevel.Document) {
throw new ArgumentOutOfRangeException("value");
}
conformanceLevel = value;
}
}
public bool CheckCharacters {
get {
return checkCharacters;
}
set {
CheckReadOnly("CheckCharacters");
checkCharacters = value;
}
}
public long MaxCharactersInDocument {
get {
return maxCharactersInDocument;
}
set {
CheckReadOnly("MaxCharactersInDocument");
if (value < 0) {
throw new ArgumentOutOfRangeException("value");
}
maxCharactersInDocument = value;
}
}
public long MaxCharactersFromEntities {
get {
return maxCharactersFromEntities;
}
set {
CheckReadOnly("MaxCharactersFromEntities");
if (value < 0) {
throw new ArgumentOutOfRangeException("value");
}
maxCharactersFromEntities = value;
}
}
// Filtering settings
public bool IgnoreWhitespace {
get {
return ignoreWhitespace;
}
set {
CheckReadOnly("IgnoreWhitespace");
ignoreWhitespace = value;
}
}
public bool IgnoreProcessingInstructions {
get {
return ignorePIs;
}
set {
CheckReadOnly("IgnoreProcessingInstructions");
ignorePIs = value;
}
}
public bool IgnoreComments {
get {
return ignoreComments;
}
set {
CheckReadOnly("IgnoreComments");
ignoreComments = value;
}
}
#if !SILVERLIGHT
[Obsolete("Use XmlReaderSettings.DtdProcessing property instead.")]
public bool ProhibitDtd {
get {
return dtdProcessing == DtdProcessing.Prohibit;
}
set {
CheckReadOnly("ProhibitDtd");
dtdProcessing = value ? DtdProcessing.Prohibit : DtdProcessing.Parse;
}
}
#endif
public DtdProcessing DtdProcessing {
get {
return dtdProcessing;
}
set {
CheckReadOnly("DtdProcessing");
if ((uint)value > (uint)DtdProcessing.Parse) {
throw new ArgumentOutOfRangeException("value");
}
dtdProcessing = value;
}
}
public bool CloseInput {
get {
return closeInput;
}
set {
CheckReadOnly("CloseInput");
closeInput = value;
}
}
#if !SILVERLIGHT
public ValidationType ValidationType {
get {
return validationType;
}
set {
CheckReadOnly("ValidationType");
if ((uint)value > (uint)ValidationType.Schema) {
throw new ArgumentOutOfRangeException("value");
}
validationType = value;
}
}
public XmlSchemaValidationFlags ValidationFlags {
get {
return validationFlags;
}
set {
CheckReadOnly("ValidationFlags");
if ((uint)value > (uint)(XmlSchemaValidationFlags.ProcessInlineSchema | XmlSchemaValidationFlags.ProcessSchemaLocation |
XmlSchemaValidationFlags.ReportValidationWarnings | XmlSchemaValidationFlags.ProcessIdentityConstraints |
XmlSchemaValidationFlags.AllowXmlAttributes)) {
throw new ArgumentOutOfRangeException("value");
}
validationFlags = value;
}
}
public XmlSchemaSet Schemas {
get {
if (schemas == null) {
schemas = new XmlSchemaSet();
}
return schemas;
}
set {
CheckReadOnly("Schemas");
schemas = value;
}
}
public event ValidationEventHandler ValidationEventHandler {
add {
CheckReadOnly("ValidationEventHandler");
valEventHandler += value;
}
remove {
CheckReadOnly("ValidationEventHandler");
valEventHandler -= value;
}
}
#endif
//
// Public methods
//
public void Reset() {
CheckReadOnly("Reset");
Initialize();
}
public XmlReaderSettings Clone() {
XmlReaderSettings clonedSettings = this.MemberwiseClone() as XmlReaderSettings;
clonedSettings.ReadOnly = false;
return clonedSettings;
}
//
// Internal methods
//
#if !SILVERLIGHT
internal ValidationEventHandler GetEventHandler() {
return valEventHandler;
}
#endif
#if !SILVERLIGHT
[ResourceConsumption(ResourceScope.Machine)]
[ResourceExposure(ResourceScope.Machine)]
#endif
internal XmlReader CreateReader(String inputUri, XmlParserContext inputContext) {
if (inputUri == null) {
throw new ArgumentNullException("inputUri");
}
if (inputUri.Length == 0) {
throw new ArgumentException(Res.GetString(Res.XmlConvert_BadUri), "inputUri");
}
// resolve and open the url
XmlResolver tmpResolver = this.GetXmlResolver();
if (tmpResolver == null) {
tmpResolver = CreateDefaultResolver();
}
Uri baseUri = tmpResolver.ResolveUri(null, inputUri);
Stream stream = (Stream)tmpResolver.GetEntity(baseUri, string.Empty, typeof(Stream));
if (stream == null) {
throw new XmlException(Res.Xml_CannotResolveUrl, inputUri);
}
// need to clone the settigns so that we can set CloseInput to true to make sure the stream gets closed in the end
XmlReaderSettings newSettings = this;
if (!newSettings.CloseInput) {
newSettings = newSettings.Clone();
newSettings.CloseInput = true;
}
try {
// create reader
return newSettings.CreateReader(stream, baseUri, null, inputContext);
}
catch {
stream.Close();
throw;
}
}
internal XmlReader CreateReader(Stream input, Uri baseUri, string baseUriString, XmlParserContext inputContext) {
if (input == null) {
throw new ArgumentNullException("input");
}
if (baseUriString == null) {
if (baseUri == null) {
baseUriString = string.Empty;
}
else {
baseUriString = baseUri.ToString();
}
}
// create text XML reader
XmlReader reader = new XmlTextReaderImpl(input, null, 0, this, baseUri, baseUriString, inputContext, closeInput);
#if !SILVERLIGHT
// wrap with validating reader
if (this.ValidationType != ValidationType.None) {
reader = AddValidation(reader);
}
#endif
return reader;
}
internal XmlReader CreateReader(TextReader input, string baseUriString, XmlParserContext inputContext) {
if (input == null) {
throw new ArgumentNullException("input");
}
if (baseUriString == null) {
baseUriString = string.Empty;
}
// create xml text reader
XmlReader reader = new XmlTextReaderImpl(input, this, baseUriString, inputContext);
#if !SILVERLIGHT
// wrap with validating reader
if (this.ValidationType != ValidationType.None) {
reader = AddValidation(reader);
}
#endif
return reader;
}
internal XmlReader CreateReader(XmlReader reader) {
if (reader == null) {
throw new ArgumentNullException("reader");
}
#if SILVERLIGHT
// wrap with conformance layer (if needed)
return AddConformanceWrapper(reader);
#else
// wrap with validating reader and a conformance layer (if needed)
return AddValidationAndConformanceWrapper(reader);
#endif
}
internal bool ReadOnly {
get {
return isReadOnly;
}
set {
isReadOnly = value;
}
}
void CheckReadOnly(string propertyName) {
if (isReadOnly) {
throw new XmlException(Res.Xml_ReadOnlyProperty, this.GetType().Name + '.' + propertyName);
}
}
//
// Private methods
//
void Initialize() {
nameTable = null;
xmlResolver = CreateDefaultResolver();
lineNumberOffset = 0;
linePositionOffset = 0;
checkCharacters = true;
conformanceLevel = ConformanceLevel.Document;
ignoreWhitespace = false;
ignorePIs = false;
ignoreComments = false;
dtdProcessing = DtdProcessing.Prohibit;
closeInput = false;
maxCharactersFromEntities = 0;
maxCharactersInDocument = 0;
#if !SILVERLIGHT
schemas = null;
validationType = ValidationType.None;
validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints;
validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;
#endif
isReadOnly = false;
}
XmlResolver CreateDefaultResolver() {
#if SILVERLIGHT
return new XmlXapResolver();
#else
return new XmlUrlResolver();
#endif
}
#if !SILVERLIGHT
internal XmlReader AddValidation(XmlReader reader) {
if (this.validationType == ValidationType.Schema) {
reader = new XsdValidatingReader(reader, this.GetXmlResolver(), this);
}
else if (this.validationType == ValidationType.DTD) {
reader = CreateDtdValidatingReader(reader);
}
return reader;
}
private XmlReader AddValidationAndConformanceWrapper(XmlReader reader) {
// wrap with DTD validating reader
if (this.validationType == ValidationType.DTD) {
reader = CreateDtdValidatingReader(reader);
}
// add conformance checking (must go after DTD validation because XmlValidatingReader works only on XmlTextReader),
// but before XSD validation because of typed value access
reader = AddConformanceWrapper(reader);
if (this.validationType == ValidationType.Schema) {
reader = new XsdValidatingReader(reader, GetXmlResolver(), this);
}
return reader;
}
private XmlValidatingReaderImpl CreateDtdValidatingReader(XmlReader baseReader) {
return new XmlValidatingReaderImpl(baseReader, this.GetEventHandler(), (this.ValidationFlags & XmlSchemaValidationFlags.ProcessIdentityConstraints) != 0);
}
#endif
internal XmlReader AddConformanceWrapper(XmlReader baseReader) {
XmlReaderSettings baseReaderSettings = baseReader.Settings;
bool checkChars = false;
bool noWhitespace = false;
bool noComments = false;
bool noPIs = false;
DtdProcessing dtdProc = (DtdProcessing)(-1);
bool needWrap = false;
if (baseReaderSettings == null) {
#pragma warning disable 618
#if SILVERLIGHT
if (this.conformanceLevel != ConformanceLevel.Auto) {
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
#else
if (this.conformanceLevel != ConformanceLevel.Auto && this.conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader)) {
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
#endif
#if !SILVERLIGHT
// get the V1 XmlTextReader ref
XmlTextReader v1XmlTextReader = baseReader as XmlTextReader;
if (v1XmlTextReader == null) {
XmlValidatingReader vr = baseReader as XmlValidatingReader;
if (vr != null) {
v1XmlTextReader = (XmlTextReader)vr.Reader;
}
}
#endif
// assume the V1 readers already do all conformance checking;
// wrap only if IgnoreWhitespace, IgnoreComments, IgnoreProcessingInstructions or ProhibitDtd is true;
if (this.ignoreWhitespace) {
WhitespaceHandling wh = WhitespaceHandling.All;
#if !SILVERLIGHT
// special-case our V1 readers to see if whey already filter whitespaces
if (v1XmlTextReader != null) {
wh = v1XmlTextReader.WhitespaceHandling;
}
#endif
if (wh == WhitespaceHandling.All) {
noWhitespace = true;
needWrap = true;
}
}
if (this.ignoreComments) {
noComments = true;
needWrap = true;
}
if (this.ignorePIs) {
noPIs = true;
needWrap = true;
}
// DTD processing
DtdProcessing baseDtdProcessing = DtdProcessing.Parse;
#if !SILVERLIGHT
if (v1XmlTextReader != null) {
baseDtdProcessing = v1XmlTextReader.DtdProcessing;
}
#endif
if ((this.dtdProcessing == DtdProcessing.Prohibit && baseDtdProcessing != DtdProcessing.Prohibit) ||
(this.dtdProcessing == DtdProcessing.Ignore && baseDtdProcessing == DtdProcessing.Parse)) {
dtdProc = this.dtdProcessing;
needWrap = true;
}
#pragma warning restore 618
}
else {
if (this.conformanceLevel != baseReaderSettings.ConformanceLevel && this.conformanceLevel != ConformanceLevel.Auto) {
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
if (this.checkCharacters && !baseReaderSettings.CheckCharacters) {
checkChars = true;
needWrap = true;
}
if (this.ignoreWhitespace && !baseReaderSettings.IgnoreWhitespace) {
noWhitespace = true;
needWrap = true;
}
if (this.ignoreComments && !baseReaderSettings.IgnoreComments) {
noComments = true;
needWrap = true;
}
if (this.ignorePIs && !baseReaderSettings.IgnoreProcessingInstructions) {
noPIs = true;
needWrap = true;
}
if ((this.dtdProcessing == DtdProcessing.Prohibit && baseReaderSettings.DtdProcessing != DtdProcessing.Prohibit) ||
(this.dtdProcessing == DtdProcessing.Ignore && baseReaderSettings.DtdProcessing == DtdProcessing.Parse)) {
dtdProc = this.dtdProcessing;
needWrap = true;
}
}
if (needWrap) {
IXmlNamespaceResolver readerAsNSResolver = baseReader as IXmlNamespaceResolver;
if (readerAsNSResolver != null) {
return new XmlCharCheckingReaderWithNS(baseReader, readerAsNSResolver, checkChars, noWhitespace, noComments, noPIs, dtdProc);
}
else {
return new XmlCharCheckingReader(baseReader, checkChars, noWhitespace, noComments, noPIs, dtdProc);
}
}
else {
return baseReader;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
using System.IO;
using System.Diagnostics;
using System.Security.Permissions;
#if !SILVERLIGHT
using System.Xml.Schema;
#endif
using System.Runtime.Versioning;
namespace System.Xml {
// XmlReaderSettings class specifies basic features of an XmlReader.
#if !SILVERLIGHT
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
#endif
public sealed class XmlReaderSettings {
//
// Fields
//
// Nametable
XmlNameTable nameTable;
// XmlResolver
XmlResolver xmlResolver;
// Text settings
int lineNumberOffset;
int linePositionOffset;
// Conformance settings
ConformanceLevel conformanceLevel;
bool checkCharacters;
long maxCharactersInDocument;
long maxCharactersFromEntities;
// Filtering settings
bool ignoreWhitespace;
bool ignorePIs;
bool ignoreComments;
// security settings
DtdProcessing dtdProcessing;
#if !SILVERLIGHT
//Validation settings
ValidationType validationType;
XmlSchemaValidationFlags validationFlags;
XmlSchemaSet schemas;
ValidationEventHandler valEventHandler;
#endif
// other settings
bool closeInput;
// read-only flag
bool isReadOnly;
//
// Constructor
//
public XmlReaderSettings() {
Initialize();
}
//
// Properties
//
// Nametable
public XmlNameTable NameTable {
get {
return nameTable;
}
set {
CheckReadOnly("NameTable");
nameTable = value;
}
}
// XmlResolver
public XmlResolver XmlResolver {
set {
CheckReadOnly("XmlResolver");
xmlResolver = value;
}
}
internal XmlResolver GetXmlResolver() {
return xmlResolver;
}
// Text settings
public int LineNumberOffset {
get {
return lineNumberOffset;
}
set {
CheckReadOnly("LineNumberOffset");
lineNumberOffset = value;
}
}
public int LinePositionOffset {
get {
return linePositionOffset;
}
set {
CheckReadOnly("LinePositionOffset");
linePositionOffset = value;
}
}
// Conformance settings
public ConformanceLevel ConformanceLevel {
get {
return conformanceLevel;
}
set {
CheckReadOnly("ConformanceLevel");
if ((uint)value > (uint)ConformanceLevel.Document) {
throw new ArgumentOutOfRangeException("value");
}
conformanceLevel = value;
}
}
public bool CheckCharacters {
get {
return checkCharacters;
}
set {
CheckReadOnly("CheckCharacters");
checkCharacters = value;
}
}
public long MaxCharactersInDocument {
get {
return maxCharactersInDocument;
}
set {
CheckReadOnly("MaxCharactersInDocument");
if (value < 0) {
throw new ArgumentOutOfRangeException("value");
}
maxCharactersInDocument = value;
}
}
public long MaxCharactersFromEntities {
get {
return maxCharactersFromEntities;
}
set {
CheckReadOnly("MaxCharactersFromEntities");
if (value < 0) {
throw new ArgumentOutOfRangeException("value");
}
maxCharactersFromEntities = value;
}
}
// Filtering settings
public bool IgnoreWhitespace {
get {
return ignoreWhitespace;
}
set {
CheckReadOnly("IgnoreWhitespace");
ignoreWhitespace = value;
}
}
public bool IgnoreProcessingInstructions {
get {
return ignorePIs;
}
set {
CheckReadOnly("IgnoreProcessingInstructions");
ignorePIs = value;
}
}
public bool IgnoreComments {
get {
return ignoreComments;
}
set {
CheckReadOnly("IgnoreComments");
ignoreComments = value;
}
}
#if !SILVERLIGHT
[Obsolete("Use XmlReaderSettings.DtdProcessing property instead.")]
public bool ProhibitDtd {
get {
return dtdProcessing == DtdProcessing.Prohibit;
}
set {
CheckReadOnly("ProhibitDtd");
dtdProcessing = value ? DtdProcessing.Prohibit : DtdProcessing.Parse;
}
}
#endif
public DtdProcessing DtdProcessing {
get {
return dtdProcessing;
}
set {
CheckReadOnly("DtdProcessing");
if ((uint)value > (uint)DtdProcessing.Parse) {
throw new ArgumentOutOfRangeException("value");
}
dtdProcessing = value;
}
}
public bool CloseInput {
get {
return closeInput;
}
set {
CheckReadOnly("CloseInput");
closeInput = value;
}
}
#if !SILVERLIGHT
public ValidationType ValidationType {
get {
return validationType;
}
set {
CheckReadOnly("ValidationType");
if ((uint)value > (uint)ValidationType.Schema) {
throw new ArgumentOutOfRangeException("value");
}
validationType = value;
}
}
public XmlSchemaValidationFlags ValidationFlags {
get {
return validationFlags;
}
set {
CheckReadOnly("ValidationFlags");
if ((uint)value > (uint)(XmlSchemaValidationFlags.ProcessInlineSchema | XmlSchemaValidationFlags.ProcessSchemaLocation |
XmlSchemaValidationFlags.ReportValidationWarnings | XmlSchemaValidationFlags.ProcessIdentityConstraints |
XmlSchemaValidationFlags.AllowXmlAttributes)) {
throw new ArgumentOutOfRangeException("value");
}
validationFlags = value;
}
}
public XmlSchemaSet Schemas {
get {
if (schemas == null) {
schemas = new XmlSchemaSet();
}
return schemas;
}
set {
CheckReadOnly("Schemas");
schemas = value;
}
}
public event ValidationEventHandler ValidationEventHandler {
add {
CheckReadOnly("ValidationEventHandler");
valEventHandler += value;
}
remove {
CheckReadOnly("ValidationEventHandler");
valEventHandler -= value;
}
}
#endif
//
// Public methods
//
public void Reset() {
CheckReadOnly("Reset");
Initialize();
}
public XmlReaderSettings Clone() {
XmlReaderSettings clonedSettings = this.MemberwiseClone() as XmlReaderSettings;
clonedSettings.ReadOnly = false;
return clonedSettings;
}
//
// Internal methods
//
#if !SILVERLIGHT
internal ValidationEventHandler GetEventHandler() {
return valEventHandler;
}
#endif
#if !SILVERLIGHT
[ResourceConsumption(ResourceScope.Machine)]
[ResourceExposure(ResourceScope.Machine)]
#endif
internal XmlReader CreateReader(String inputUri, XmlParserContext inputContext) {
if (inputUri == null) {
throw new ArgumentNullException("inputUri");
}
if (inputUri.Length == 0) {
throw new ArgumentException(Res.GetString(Res.XmlConvert_BadUri), "inputUri");
}
// resolve and open the url
XmlResolver tmpResolver = this.GetXmlResolver();
if (tmpResolver == null) {
tmpResolver = CreateDefaultResolver();
}
Uri baseUri = tmpResolver.ResolveUri(null, inputUri);
Stream stream = (Stream)tmpResolver.GetEntity(baseUri, string.Empty, typeof(Stream));
if (stream == null) {
throw new XmlException(Res.Xml_CannotResolveUrl, inputUri);
}
// need to clone the settigns so that we can set CloseInput to true to make sure the stream gets closed in the end
XmlReaderSettings newSettings = this;
if (!newSettings.CloseInput) {
newSettings = newSettings.Clone();
newSettings.CloseInput = true;
}
try {
// create reader
return newSettings.CreateReader(stream, baseUri, null, inputContext);
}
catch {
stream.Close();
throw;
}
}
internal XmlReader CreateReader(Stream input, Uri baseUri, string baseUriString, XmlParserContext inputContext) {
if (input == null) {
throw new ArgumentNullException("input");
}
if (baseUriString == null) {
if (baseUri == null) {
baseUriString = string.Empty;
}
else {
baseUriString = baseUri.ToString();
}
}
// create text XML reader
XmlReader reader = new XmlTextReaderImpl(input, null, 0, this, baseUri, baseUriString, inputContext, closeInput);
#if !SILVERLIGHT
// wrap with validating reader
if (this.ValidationType != ValidationType.None) {
reader = AddValidation(reader);
}
#endif
return reader;
}
internal XmlReader CreateReader(TextReader input, string baseUriString, XmlParserContext inputContext) {
if (input == null) {
throw new ArgumentNullException("input");
}
if (baseUriString == null) {
baseUriString = string.Empty;
}
// create xml text reader
XmlReader reader = new XmlTextReaderImpl(input, this, baseUriString, inputContext);
#if !SILVERLIGHT
// wrap with validating reader
if (this.ValidationType != ValidationType.None) {
reader = AddValidation(reader);
}
#endif
return reader;
}
internal XmlReader CreateReader(XmlReader reader) {
if (reader == null) {
throw new ArgumentNullException("reader");
}
#if SILVERLIGHT
// wrap with conformance layer (if needed)
return AddConformanceWrapper(reader);
#else
// wrap with validating reader and a conformance layer (if needed)
return AddValidationAndConformanceWrapper(reader);
#endif
}
internal bool ReadOnly {
get {
return isReadOnly;
}
set {
isReadOnly = value;
}
}
void CheckReadOnly(string propertyName) {
if (isReadOnly) {
throw new XmlException(Res.Xml_ReadOnlyProperty, this.GetType().Name + '.' + propertyName);
}
}
//
// Private methods
//
void Initialize() {
nameTable = null;
xmlResolver = CreateDefaultResolver();
lineNumberOffset = 0;
linePositionOffset = 0;
checkCharacters = true;
conformanceLevel = ConformanceLevel.Document;
ignoreWhitespace = false;
ignorePIs = false;
ignoreComments = false;
dtdProcessing = DtdProcessing.Prohibit;
closeInput = false;
maxCharactersFromEntities = 0;
maxCharactersInDocument = 0;
#if !SILVERLIGHT
schemas = null;
validationType = ValidationType.None;
validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints;
validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;
#endif
isReadOnly = false;
}
XmlResolver CreateDefaultResolver() {
#if SILVERLIGHT
return new XmlXapResolver();
#else
return new XmlUrlResolver();
#endif
}
#if !SILVERLIGHT
internal XmlReader AddValidation(XmlReader reader) {
if (this.validationType == ValidationType.Schema) {
reader = new XsdValidatingReader(reader, this.GetXmlResolver(), this);
}
else if (this.validationType == ValidationType.DTD) {
reader = CreateDtdValidatingReader(reader);
}
return reader;
}
private XmlReader AddValidationAndConformanceWrapper(XmlReader reader) {
// wrap with DTD validating reader
if (this.validationType == ValidationType.DTD) {
reader = CreateDtdValidatingReader(reader);
}
// add conformance checking (must go after DTD validation because XmlValidatingReader works only on XmlTextReader),
// but before XSD validation because of typed value access
reader = AddConformanceWrapper(reader);
if (this.validationType == ValidationType.Schema) {
reader = new XsdValidatingReader(reader, GetXmlResolver(), this);
}
return reader;
}
private XmlValidatingReaderImpl CreateDtdValidatingReader(XmlReader baseReader) {
return new XmlValidatingReaderImpl(baseReader, this.GetEventHandler(), (this.ValidationFlags & XmlSchemaValidationFlags.ProcessIdentityConstraints) != 0);
}
#endif
internal XmlReader AddConformanceWrapper(XmlReader baseReader) {
XmlReaderSettings baseReaderSettings = baseReader.Settings;
bool checkChars = false;
bool noWhitespace = false;
bool noComments = false;
bool noPIs = false;
DtdProcessing dtdProc = (DtdProcessing)(-1);
bool needWrap = false;
if (baseReaderSettings == null) {
#pragma warning disable 618
#if SILVERLIGHT
if (this.conformanceLevel != ConformanceLevel.Auto) {
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
#else
if (this.conformanceLevel != ConformanceLevel.Auto && this.conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader)) {
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
#endif
#if !SILVERLIGHT
// get the V1 XmlTextReader ref
XmlTextReader v1XmlTextReader = baseReader as XmlTextReader;
if (v1XmlTextReader == null) {
XmlValidatingReader vr = baseReader as XmlValidatingReader;
if (vr != null) {
v1XmlTextReader = (XmlTextReader)vr.Reader;
}
}
#endif
// assume the V1 readers already do all conformance checking;
// wrap only if IgnoreWhitespace, IgnoreComments, IgnoreProcessingInstructions or ProhibitDtd is true;
if (this.ignoreWhitespace) {
WhitespaceHandling wh = WhitespaceHandling.All;
#if !SILVERLIGHT
// special-case our V1 readers to see if whey already filter whitespaces
if (v1XmlTextReader != null) {
wh = v1XmlTextReader.WhitespaceHandling;
}
#endif
if (wh == WhitespaceHandling.All) {
noWhitespace = true;
needWrap = true;
}
}
if (this.ignoreComments) {
noComments = true;
needWrap = true;
}
if (this.ignorePIs) {
noPIs = true;
needWrap = true;
}
// DTD processing
DtdProcessing baseDtdProcessing = DtdProcessing.Parse;
#if !SILVERLIGHT
if (v1XmlTextReader != null) {
baseDtdProcessing = v1XmlTextReader.DtdProcessing;
}
#endif
if ((this.dtdProcessing == DtdProcessing.Prohibit && baseDtdProcessing != DtdProcessing.Prohibit) ||
(this.dtdProcessing == DtdProcessing.Ignore && baseDtdProcessing == DtdProcessing.Parse)) {
dtdProc = this.dtdProcessing;
needWrap = true;
}
#pragma warning restore 618
}
else {
if (this.conformanceLevel != baseReaderSettings.ConformanceLevel && this.conformanceLevel != ConformanceLevel.Auto) {
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
if (this.checkCharacters && !baseReaderSettings.CheckCharacters) {
checkChars = true;
needWrap = true;
}
if (this.ignoreWhitespace && !baseReaderSettings.IgnoreWhitespace) {
noWhitespace = true;
needWrap = true;
}
if (this.ignoreComments && !baseReaderSettings.IgnoreComments) {
noComments = true;
needWrap = true;
}
if (this.ignorePIs && !baseReaderSettings.IgnoreProcessingInstructions) {
noPIs = true;
needWrap = true;
}
if ((this.dtdProcessing == DtdProcessing.Prohibit && baseReaderSettings.DtdProcessing != DtdProcessing.Prohibit) ||
(this.dtdProcessing == DtdProcessing.Ignore && baseReaderSettings.DtdProcessing == DtdProcessing.Parse)) {
dtdProc = this.dtdProcessing;
needWrap = true;
}
}
if (needWrap) {
IXmlNamespaceResolver readerAsNSResolver = baseReader as IXmlNamespaceResolver;
if (readerAsNSResolver != null) {
return new XmlCharCheckingReaderWithNS(baseReader, readerAsNSResolver, checkChars, noWhitespace, noComments, noPIs, dtdProc);
}
else {
return new XmlCharCheckingReader(baseReader, checkChars, noWhitespace, noComments, noPIs, dtdProc);
}
}
else {
return baseReader;
}
}
}
}
// 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
- PrintDialogException.cs
- WebPartManager.cs
- StyleSheetRefUrlEditor.cs
- PriorityRange.cs
- HasCopySemanticsAttribute.cs
- ActivityLocationReferenceEnvironment.cs
- CacheForPrimitiveTypes.cs
- CompareInfo.cs
- ViewKeyConstraint.cs
- ProgressBar.cs
- SmtpLoginAuthenticationModule.cs
- ComEventsInfo.cs
- SafeBitVector32.cs
- LocatorManager.cs
- NetPeerTcpBindingCollectionElement.cs
- PropertyStore.cs
- ActiveXHost.cs
- SynchronousSendBindingElement.cs
- DbDataRecord.cs
- SiteMapNodeItemEventArgs.cs
- RegexEditorDialog.cs
- ScriptResourceAttribute.cs
- HttpCacheVaryByContentEncodings.cs
- Pen.cs
- TripleDESCryptoServiceProvider.cs
- WriteFileContext.cs
- DocumentPropertiesDialog.cs
- UncommonField.cs
- XmlSerializerFactory.cs
- Fx.cs
- ReachDocumentReferenceCollectionSerializer.cs
- AlphaSortedEnumConverter.cs
- ImageCodecInfoPrivate.cs
- SqlClientMetaDataCollectionNames.cs
- TextServicesHost.cs
- EntityContainerAssociationSetEnd.cs
- WmlCommandAdapter.cs
- QueueProcessor.cs
- RefExpr.cs
- Logging.cs
- TableLayoutPanelBehavior.cs
- CharKeyFrameCollection.cs
- ServiceOperationParameter.cs
- LocalFileSettingsProvider.cs
- CdpEqualityComparer.cs
- ThreadStateException.cs
- UnsafePeerToPeerMethods.cs
- WmlSelectionListAdapter.cs
- InstanceNotFoundException.cs
- WindowAutomationPeer.cs
- DbReferenceCollection.cs
- RemotingException.cs
- RelationshipNavigation.cs
- RIPEMD160.cs
- FacetEnabledSchemaElement.cs
- TdsParser.cs
- NamespaceEmitter.cs
- Utils.cs
- ReservationNotFoundException.cs
- XmlAnyElementAttributes.cs
- TypeConverter.cs
- ContentType.cs
- ScriptControl.cs
- SymLanguageVendor.cs
- ReadonlyMessageFilter.cs
- CompilerGlobalScopeAttribute.cs
- Control.cs
- MdbDataFileEditor.cs
- SafeWaitHandle.cs
- ContextDataSourceView.cs
- DispatcherBuilder.cs
- EntityTypeEmitter.cs
- DrawItemEvent.cs
- XmlAnyElementAttributes.cs
- ItemContainerGenerator.cs
- ProviderIncompatibleException.cs
- RightsManagementResourceHelper.cs
- HandlerBase.cs
- HandleRef.cs
- GradientBrush.cs
- SQLInt32Storage.cs
- PermissionToken.cs
- OracleException.cs
- ExpanderAutomationPeer.cs
- PagesSection.cs
- SequentialOutput.cs
- OdbcConnectionHandle.cs
- ValidationRule.cs
- DBDataPermissionAttribute.cs
- tibetanshape.cs
- AccessDataSource.cs
- PolyQuadraticBezierSegment.cs
- XdrBuilder.cs
- SQLInt32Storage.cs
- HandlerWithFactory.cs
- ListItemConverter.cs
- LocationSectionRecord.cs
- EventDescriptor.cs
- TextFormatterHost.cs
- OverflowException.cs