Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Xml / System / Xml / Core / XmlWriterSettings.cs / 1305376 / XmlWriterSettings.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Security.Permissions;
using System.Runtime.Versioning;
#if !SILVERLIGHT
#if !HIDE_XSL
using System.Xml.Xsl.Runtime;
#endif
#endif
namespace System.Xml {
#if !SILVERLIGHT
public enum XmlOutputMethod {
Xml = 0, // Use Xml 1.0 rules to serialize
Html = 1, // Use Html rules specified by Xslt specification to serialize
Text = 2, // Only serialize text blocks
AutoDetect = 3, // Choose between Xml and Html output methods at runtime (using Xslt rules to do so)
}
#endif
///
/// Three-state logic enumeration.
///
internal enum TriState {
Unknown = -1,
False = 0,
True = 1,
};
internal enum XmlStandalone {
// Do not change the constants - XmlBinaryWriter depends in it
Omit = 0,
Yes = 1,
No = 2,
}
// XmlWriterSettings class specifies basic features of an XmlWriter.
#if !SILVERLIGHT
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
#endif
public sealed class XmlWriterSettings {
//
// Fields
//
// Text settings
Encoding encoding;
bool omitXmlDecl;
NewLineHandling newLineHandling;
string newLineChars;
TriState indent;
string indentChars;
bool newLineOnAttributes;
bool closeOutput;
NamespaceHandling namespaceHandling;
// Conformance settings
ConformanceLevel conformanceLevel;
bool checkCharacters;
#if !SILVERLIGHT
// Xslt settings
XmlOutputMethod outputMethod;
List cdataSections = new List();
bool mergeCDataSections;
string mediaType;
string docTypeSystem;
string docTypePublic;
XmlStandalone standalone;
bool autoXmlDecl;
#endif
// read-only flag
bool isReadOnly;
//
// Constructor
//
public XmlWriterSettings() {
Initialize();
}
//
// Properties
//
// Text
public Encoding Encoding {
get {
return encoding;
}
set {
CheckReadOnly("Encoding");
encoding = value;
}
}
// True if an xml declaration should *not* be written.
public bool OmitXmlDeclaration {
get {
return omitXmlDecl;
}
set {
CheckReadOnly("OmitXmlDeclaration");
omitXmlDecl = value;
}
}
// See NewLineHandling enum for details.
public NewLineHandling NewLineHandling {
get {
return newLineHandling;
}
set {
CheckReadOnly("NewLineHandling");
if ((uint)value > (uint)NewLineHandling.None) {
throw new ArgumentOutOfRangeException("value");
}
newLineHandling = value;
}
}
// Line terminator string. By default, this is a carriage return followed by a line feed ("\r\n").
public string NewLineChars {
get {
return newLineChars;
}
set {
CheckReadOnly("NewLineChars");
if (value == null) {
throw new ArgumentNullException("value");
}
newLineChars = value;
}
}
// True if output should be indented using rules that are appropriate to the output rules (i.e. Xml, Html, etc).
public bool Indent {
get {
return indent == TriState.True;
}
set {
CheckReadOnly("Indent");
indent = value ? TriState.True : TriState.False;
}
}
// Characters to use when indenting. This is usually tab or some spaces, but can be anything.
public string IndentChars {
get {
return indentChars;
}
set {
CheckReadOnly("IndentChars");
if (value == null) {
throw new ArgumentNullException("value");
}
indentChars = value;
}
}
// Whether or not indent attributes on new lines.
public bool NewLineOnAttributes {
get {
return newLineOnAttributes;
}
set {
CheckReadOnly("NewLineOnAttributes");
newLineOnAttributes = value;
}
}
// Whether or not the XmlWriter should close the underlying stream or TextWriter when Close is called on the XmlWriter.
public bool CloseOutput {
get {
return closeOutput;
}
set {
CheckReadOnly("CloseOutput");
closeOutput = value;
}
}
// Conformance
// See ConformanceLevel enum for details.
public ConformanceLevel ConformanceLevel {
get {
return conformanceLevel;
}
set {
CheckReadOnly("ConformanceLevel");
if ((uint)value > (uint)ConformanceLevel.Document) {
throw new ArgumentOutOfRangeException("value");
}
conformanceLevel = value;
}
}
// Whether or not to check content characters that they are valid XML characters.
public bool CheckCharacters {
get {
return checkCharacters;
}
set {
CheckReadOnly("CheckCharacters");
checkCharacters = value;
}
}
// Whether ot not to remove duplicate namespace declarations
public NamespaceHandling NamespaceHandling {
get {
return namespaceHandling;
}
set {
CheckReadOnly("NamespaceHandling");
if ((uint)value > (uint)(NamespaceHandling.OmitDuplicates)) {
throw new ArgumentOutOfRangeException("value");
}
namespaceHandling = value;
}
}
#if !SILVERLIGHT
// Specifies the method (Html, Xml, etc.) that will be used to serialize the result tree.
public XmlOutputMethod OutputMethod {
get {
return outputMethod;
}
internal set {
outputMethod = value;
}
}
#endif
//
// Public methods
//
public void Reset() {
CheckReadOnly("Reset");
Initialize();
}
// Deep clone all settings (except read-only, which is always set to false). The original and new objects
// can now be set independently of each other.
public XmlWriterSettings Clone() {
XmlWriterSettings clonedSettings = MemberwiseClone() as XmlWriterSettings;
#if !SILVERLIGHT
// Deep clone shared settings that are not immutable
clonedSettings.cdataSections = new List(cdataSections);
#endif
clonedSettings.isReadOnly = false;
return clonedSettings;
}
//
// Internal properties
//
#if !SILVERLIGHT
// Set of XmlQualifiedNames that identify any elements that need to have text children wrapped in CData sections.
internal List CDataSectionElements {
get {
Debug.Assert(cdataSections != null);
return cdataSections;
}
}
internal bool MergeCDataSections {
get {
return mergeCDataSections;
}
set {
CheckReadOnly("MergeCDataSections");
mergeCDataSections = value;
}
}
// Used in Html writer when writing Meta element. Null denotes the default media type.
internal string MediaType {
get {
return mediaType;
}
set {
CheckReadOnly("MediaType");
mediaType = value;
}
}
// System Id in doc-type declaration. Null denotes the absence of the system Id.
internal string DocTypeSystem {
get {
return docTypeSystem;
}
set {
CheckReadOnly("DocTypeSystem");
docTypeSystem = value;
}
}
// Public Id in doc-type declaration. Null denotes the absence of the public Id.
internal string DocTypePublic {
get {
return docTypePublic;
}
set {
CheckReadOnly("DocTypePublic");
docTypePublic = value;
}
}
// Yes for standalone="yes", No for standalone="no", and Omit for no standalone.
internal XmlStandalone Standalone {
get {
return standalone;
}
set {
CheckReadOnly("Standalone");
standalone = value;
}
}
// True if an xml declaration should automatically be output (no need to call WriteStartDocument)
internal bool AutoXmlDeclaration {
get {
return autoXmlDecl;
}
set {
CheckReadOnly("AutoXmlDeclaration");
autoXmlDecl = value;
}
}
// If TriState.Unknown, then Indent property was not explicitly set. In this case, the AutoDetect output
// method will default to Indent=true for Html and Indent=false for Xml.
internal TriState IndentInternal {
get {
return indent;
}
set {
indent = value;
}
}
internal bool IsQuerySpecific {
get {
return cdataSections.Count != 0 || docTypePublic != null ||
docTypeSystem != null || standalone == XmlStandalone.Yes;
}
}
#endif
#if !SILVERLIGHT
[ResourceConsumption(ResourceScope.Machine)]
[ResourceExposure(ResourceScope.Machine)]
internal XmlWriter CreateWriter(string outputFileName) {
if (outputFileName == null) {
throw new ArgumentNullException("outputFileName");
}
// need to clone the settigns so that we can set CloseOutput to true to make sure the stream gets closed in the end
XmlWriterSettings newSettings = this;
if (!newSettings.CloseOutput) {
newSettings = newSettings.Clone();
newSettings.CloseOutput = true;
}
FileStream fs = null;
try {
// open file stream
fs = new FileStream(outputFileName, FileMode.Create, FileAccess.Write, FileShare.Read);
// create writer
return newSettings.CreateWriter(fs);
}
catch {
if (fs != null) {
fs.Close();
}
throw;
}
}
#endif
internal XmlWriter CreateWriter(Stream output) {
if (output == null) {
throw new ArgumentNullException("output");
}
XmlWriter writer;
// create raw writer
#if SILVERLIGHT
Debug.Assert(Encoding.UTF8.WebName == "utf-8");
if (this.Encoding.WebName == "utf-8") { // Encoding.CodePage is not supported in Silverlight
// create raw UTF-8 writer
if (this.Indent) {
writer = new XmlUtf8RawTextWriterIndent(output, this);
}
else {
writer = new XmlUtf8RawTextWriter(output, this);
}
}
else {
// create raw writer for other encodings
if (this.Indent) {
writer = new XmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new XmlEncodedRawTextWriter(output, this);
}
}
#else
Debug.Assert(Encoding.UTF8.WebName == "utf-8");
if (this.Encoding.WebName == "utf-8") { // Encoding.CodePage is not supported in Silverlight
// create raw UTF-8 writer
switch (this.OutputMethod) {
case XmlOutputMethod.Xml:
if (this.Indent) {
writer = new XmlUtf8RawTextWriterIndent(output, this);
}
else {
writer = new XmlUtf8RawTextWriter(output, this);
}
break;
case XmlOutputMethod.Html:
if (this.Indent) {
writer = new HtmlUtf8RawTextWriterIndent(output, this);
}
else {
writer = new HtmlUtf8RawTextWriter(output, this);
}
break;
case XmlOutputMethod.Text:
writer = new TextUtf8RawTextWriter(output, this);
break;
case XmlOutputMethod.AutoDetect:
writer = new XmlAutoDetectWriter(output, this);
break;
default:
Debug.Assert(false, "Invalid XmlOutputMethod setting.");
return null;
}
}
else {
// Otherwise, create a general-purpose writer than can do any encoding
switch (this.OutputMethod) {
case XmlOutputMethod.Xml:
if (this.Indent) {
writer = new XmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new XmlEncodedRawTextWriter(output, this);
}
break;
case XmlOutputMethod.Html:
if (this.Indent) {
writer = new HtmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new HtmlEncodedRawTextWriter(output, this);
}
break;
case XmlOutputMethod.Text:
writer = new TextEncodedRawTextWriter(output, this);
break;
case XmlOutputMethod.AutoDetect:
writer = new XmlAutoDetectWriter(output, this);
break;
default:
Debug.Assert(false, "Invalid XmlOutputMethod setting.");
return null;
}
}
// Wrap with Xslt/XQuery specific writer if needed;
// XmlOutputMethod.AutoDetect writer does this lazily when it creates the underlying Xml or Html writer.
if (this.OutputMethod != XmlOutputMethod.AutoDetect) {
if (this.IsQuerySpecific) {
// Create QueryOutputWriter if CData sections or DocType need to be tracked
writer = new QueryOutputWriter((XmlRawWriter)writer, this);
}
}
#endif // !SILVERLIGHT
// wrap with well-formed writer
writer = new XmlWellFormedWriter(writer, this);
return writer;
}
internal XmlWriter CreateWriter(TextWriter output) {
if (output == null) {
throw new ArgumentNullException("output");
}
XmlWriter writer;
// create raw writer
#if SILVERLIGHT
if (this.Indent) {
writer = new XmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new XmlEncodedRawTextWriter(output, this);
}
#else
switch (this.OutputMethod) {
case XmlOutputMethod.Xml:
if (this.Indent) {
writer = new XmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new XmlEncodedRawTextWriter(output, this);
}
break;
case XmlOutputMethod.Html:
if (this.Indent) {
writer = new HtmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new HtmlEncodedRawTextWriter(output, this);
}
break;
case XmlOutputMethod.Text:
writer = new TextEncodedRawTextWriter(output, this);
break;
case XmlOutputMethod.AutoDetect:
writer = new XmlAutoDetectWriter(output, this);
break;
default:
Debug.Assert(false, "Invalid XmlOutputMethod setting.");
return null;
}
// XmlOutputMethod.AutoDetect writer does this lazily when it creates the underlying Xml or Html writer.
if (this.OutputMethod != XmlOutputMethod.AutoDetect) {
if (this.IsQuerySpecific) {
// Create QueryOutputWriter if CData sections or DocType need to be tracked
writer = new QueryOutputWriter((XmlRawWriter)writer, this);
}
}
#endif //SILVERLIGHT
// wrap with well-formed writer
writer = new XmlWellFormedWriter(writer, this);
return writer;
}
internal XmlWriter CreateWriter(XmlWriter output) {
if (output == null) {
throw new ArgumentNullException("output");
}
return AddConformanceWrapper(output);
}
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() {
encoding = Encoding.UTF8;
omitXmlDecl = false;
newLineHandling = NewLineHandling.Replace;
newLineChars = Environment.NewLine; // "\r\n" on Windows, "\n" on Unix
indent = TriState.Unknown;
indentChars = " ";
newLineOnAttributes = false;
closeOutput = false;
namespaceHandling = NamespaceHandling.Default;
conformanceLevel = ConformanceLevel.Document;
checkCharacters = true;
#if !SILVERLIGHT
outputMethod = XmlOutputMethod.Xml;
cdataSections.Clear();
mergeCDataSections = false;
mediaType = null;
docTypeSystem = null;
docTypePublic = null;
standalone = XmlStandalone.Omit;
#endif
isReadOnly = false;
}
private XmlWriter AddConformanceWrapper(XmlWriter baseWriter) {
ConformanceLevel confLevel = ConformanceLevel.Auto;
XmlWriterSettings baseWriterSettings = baseWriter.Settings;
bool checkValues = false;
bool checkNames = false;
bool replaceNewLines = false;
bool needWrap = false;
if (baseWriterSettings == null) {
// assume the V1 writer already do all conformance checking;
// wrap only if NewLineHandling == Replace or CheckCharacters is true
if (this.newLineHandling == NewLineHandling.Replace) {
replaceNewLines = true;
needWrap = true;
}
if (this.checkCharacters) {
checkValues = true;
needWrap = true;
}
}
else {
if (this.conformanceLevel != baseWriterSettings.ConformanceLevel) {
confLevel = this.ConformanceLevel;
needWrap = true;
}
if (this.checkCharacters && !baseWriterSettings.CheckCharacters) {
checkValues = true;
checkNames = confLevel == ConformanceLevel.Auto;
needWrap = true;
}
if (this.newLineHandling == NewLineHandling.Replace &&
baseWriterSettings.NewLineHandling == NewLineHandling.None) {
replaceNewLines = true;
needWrap = true;
}
}
XmlWriter writer = baseWriter;
if (needWrap) {
if (confLevel != ConformanceLevel.Auto) {
writer = new XmlWellFormedWriter(writer, this);
}
if (checkValues || replaceNewLines) {
writer = new XmlCharCheckingWriter(writer, checkValues, checkNames, replaceNewLines, this.NewLineChars);
}
}
#if !SILVERLIGHT
if (this.IsQuerySpecific && (baseWriterSettings == null || !baseWriterSettings.IsQuerySpecific)) {
// Create QueryOutputWriterV1 if CData sections or DocType need to be tracked
writer = new QueryOutputWriterV1(writer, this);
}
#endif
return writer;
}
//
// Internal methods
//
#if !SILVERLIGHT
#if !HIDE_XSL
///
/// Serialize the object to BinaryWriter.
///
internal void GetObjectData(XmlQueryDataWriter writer) {
// Encoding encoding;
// NOTE: For Encoding we serialize only CodePage, and ignore EncoderFallback/DecoderFallback.
// It suffices for XSLT purposes, but not in the general case.
Debug.Assert(Encoding.Equals(Encoding.GetEncoding(Encoding.CodePage)), "Cannot serialize encoding correctly");
writer.Write(Encoding.CodePage);
// bool omitXmlDecl;
writer.Write(OmitXmlDeclaration);
// NewLineHandling newLineHandling;
writer.Write((sbyte)NewLineHandling);
// string newLineChars;
writer.WriteStringQ(NewLineChars);
// TriState indent;
writer.Write((sbyte)IndentInternal);
// string indentChars;
writer.WriteStringQ(IndentChars);
// bool newLineOnAttributes;
writer.Write(NewLineOnAttributes);
// bool closeOutput;
writer.Write(CloseOutput);
// ConformanceLevel conformanceLevel;
writer.Write((sbyte)ConformanceLevel);
// bool checkCharacters;
writer.Write(CheckCharacters);
// XmlOutputMethod outputMethod;
writer.Write((sbyte)outputMethod);
// List cdataSections;
writer.Write(cdataSections.Count);
foreach (XmlQualifiedName qname in cdataSections) {
writer.Write(qname.Name);
writer.Write(qname.Namespace);
}
// bool mergeCDataSections;
writer.Write(mergeCDataSections);
// string mediaType;
writer.WriteStringQ(mediaType);
// string docTypeSystem;
writer.WriteStringQ(docTypeSystem);
// string docTypePublic;
writer.WriteStringQ(docTypePublic);
// XmlStandalone standalone;
writer.Write((sbyte)standalone);
// bool autoXmlDecl;
writer.Write(autoXmlDecl);
// bool isReadOnly;
writer.Write(ReadOnly);
}
///
/// Deserialize the object from BinaryReader.
///
internal XmlWriterSettings(XmlQueryDataReader reader) {
// Encoding encoding;
Encoding = Encoding.GetEncoding(reader.ReadInt32());
// bool omitXmlDecl;
OmitXmlDeclaration = reader.ReadBoolean();
// NewLineHandling newLineHandling;
NewLineHandling = (NewLineHandling)reader.ReadSByte(0, (sbyte)NewLineHandling.None);
// string newLineChars;
NewLineChars = reader.ReadStringQ();
// TriState indent;
IndentInternal = (TriState)reader.ReadSByte((sbyte)TriState.Unknown, (sbyte)TriState.True);
// string indentChars;
IndentChars = reader.ReadStringQ();
// bool newLineOnAttributes;
NewLineOnAttributes = reader.ReadBoolean();
// bool closeOutput;
CloseOutput = reader.ReadBoolean();
// ConformanceLevel conformanceLevel;
ConformanceLevel = (ConformanceLevel)reader.ReadSByte(0, (sbyte)ConformanceLevel.Document);
// bool checkCharacters;
CheckCharacters = reader.ReadBoolean();
// XmlOutputMethod outputMethod;
outputMethod = (XmlOutputMethod)reader.ReadSByte(0, (sbyte)XmlOutputMethod.AutoDetect);
// List cdataSections;
int length = reader.ReadInt32();
cdataSections = new List(length);
for (int idx = 0; idx < length; idx++) {
cdataSections.Add(new XmlQualifiedName(reader.ReadString(), reader.ReadString()));
}
// bool mergeCDataSections;
mergeCDataSections = reader.ReadBoolean();
// string mediaType;
mediaType = reader.ReadStringQ();
// string docTypeSystem;
docTypeSystem = reader.ReadStringQ();
// string docTypePublic;
docTypePublic = reader.ReadStringQ();
// XmlStandalone standalone;
Standalone = (XmlStandalone)reader.ReadSByte(0, (sbyte)XmlStandalone.No);
// bool autoXmlDecl;
autoXmlDecl = reader.ReadBoolean();
// bool isReadOnly;
ReadOnly = reader.ReadBoolean();
}
#else
internal void GetObjectData(object writer) { }
internal XmlWriterSettings(object reader) { }
#endif
#endif
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Security.Permissions;
using System.Runtime.Versioning;
#if !SILVERLIGHT
#if !HIDE_XSL
using System.Xml.Xsl.Runtime;
#endif
#endif
namespace System.Xml {
#if !SILVERLIGHT
public enum XmlOutputMethod {
Xml = 0, // Use Xml 1.0 rules to serialize
Html = 1, // Use Html rules specified by Xslt specification to serialize
Text = 2, // Only serialize text blocks
AutoDetect = 3, // Choose between Xml and Html output methods at runtime (using Xslt rules to do so)
}
#endif
///
/// Three-state logic enumeration.
///
internal enum TriState {
Unknown = -1,
False = 0,
True = 1,
};
internal enum XmlStandalone {
// Do not change the constants - XmlBinaryWriter depends in it
Omit = 0,
Yes = 1,
No = 2,
}
// XmlWriterSettings class specifies basic features of an XmlWriter.
#if !SILVERLIGHT
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
#endif
public sealed class XmlWriterSettings {
//
// Fields
//
// Text settings
Encoding encoding;
bool omitXmlDecl;
NewLineHandling newLineHandling;
string newLineChars;
TriState indent;
string indentChars;
bool newLineOnAttributes;
bool closeOutput;
NamespaceHandling namespaceHandling;
// Conformance settings
ConformanceLevel conformanceLevel;
bool checkCharacters;
#if !SILVERLIGHT
// Xslt settings
XmlOutputMethod outputMethod;
List cdataSections = new List();
bool mergeCDataSections;
string mediaType;
string docTypeSystem;
string docTypePublic;
XmlStandalone standalone;
bool autoXmlDecl;
#endif
// read-only flag
bool isReadOnly;
//
// Constructor
//
public XmlWriterSettings() {
Initialize();
}
//
// Properties
//
// Text
public Encoding Encoding {
get {
return encoding;
}
set {
CheckReadOnly("Encoding");
encoding = value;
}
}
// True if an xml declaration should *not* be written.
public bool OmitXmlDeclaration {
get {
return omitXmlDecl;
}
set {
CheckReadOnly("OmitXmlDeclaration");
omitXmlDecl = value;
}
}
// See NewLineHandling enum for details.
public NewLineHandling NewLineHandling {
get {
return newLineHandling;
}
set {
CheckReadOnly("NewLineHandling");
if ((uint)value > (uint)NewLineHandling.None) {
throw new ArgumentOutOfRangeException("value");
}
newLineHandling = value;
}
}
// Line terminator string. By default, this is a carriage return followed by a line feed ("\r\n").
public string NewLineChars {
get {
return newLineChars;
}
set {
CheckReadOnly("NewLineChars");
if (value == null) {
throw new ArgumentNullException("value");
}
newLineChars = value;
}
}
// True if output should be indented using rules that are appropriate to the output rules (i.e. Xml, Html, etc).
public bool Indent {
get {
return indent == TriState.True;
}
set {
CheckReadOnly("Indent");
indent = value ? TriState.True : TriState.False;
}
}
// Characters to use when indenting. This is usually tab or some spaces, but can be anything.
public string IndentChars {
get {
return indentChars;
}
set {
CheckReadOnly("IndentChars");
if (value == null) {
throw new ArgumentNullException("value");
}
indentChars = value;
}
}
// Whether or not indent attributes on new lines.
public bool NewLineOnAttributes {
get {
return newLineOnAttributes;
}
set {
CheckReadOnly("NewLineOnAttributes");
newLineOnAttributes = value;
}
}
// Whether or not the XmlWriter should close the underlying stream or TextWriter when Close is called on the XmlWriter.
public bool CloseOutput {
get {
return closeOutput;
}
set {
CheckReadOnly("CloseOutput");
closeOutput = value;
}
}
// Conformance
// See ConformanceLevel enum for details.
public ConformanceLevel ConformanceLevel {
get {
return conformanceLevel;
}
set {
CheckReadOnly("ConformanceLevel");
if ((uint)value > (uint)ConformanceLevel.Document) {
throw new ArgumentOutOfRangeException("value");
}
conformanceLevel = value;
}
}
// Whether or not to check content characters that they are valid XML characters.
public bool CheckCharacters {
get {
return checkCharacters;
}
set {
CheckReadOnly("CheckCharacters");
checkCharacters = value;
}
}
// Whether ot not to remove duplicate namespace declarations
public NamespaceHandling NamespaceHandling {
get {
return namespaceHandling;
}
set {
CheckReadOnly("NamespaceHandling");
if ((uint)value > (uint)(NamespaceHandling.OmitDuplicates)) {
throw new ArgumentOutOfRangeException("value");
}
namespaceHandling = value;
}
}
#if !SILVERLIGHT
// Specifies the method (Html, Xml, etc.) that will be used to serialize the result tree.
public XmlOutputMethod OutputMethod {
get {
return outputMethod;
}
internal set {
outputMethod = value;
}
}
#endif
//
// Public methods
//
public void Reset() {
CheckReadOnly("Reset");
Initialize();
}
// Deep clone all settings (except read-only, which is always set to false). The original and new objects
// can now be set independently of each other.
public XmlWriterSettings Clone() {
XmlWriterSettings clonedSettings = MemberwiseClone() as XmlWriterSettings;
#if !SILVERLIGHT
// Deep clone shared settings that are not immutable
clonedSettings.cdataSections = new List(cdataSections);
#endif
clonedSettings.isReadOnly = false;
return clonedSettings;
}
//
// Internal properties
//
#if !SILVERLIGHT
// Set of XmlQualifiedNames that identify any elements that need to have text children wrapped in CData sections.
internal List CDataSectionElements {
get {
Debug.Assert(cdataSections != null);
return cdataSections;
}
}
internal bool MergeCDataSections {
get {
return mergeCDataSections;
}
set {
CheckReadOnly("MergeCDataSections");
mergeCDataSections = value;
}
}
// Used in Html writer when writing Meta element. Null denotes the default media type.
internal string MediaType {
get {
return mediaType;
}
set {
CheckReadOnly("MediaType");
mediaType = value;
}
}
// System Id in doc-type declaration. Null denotes the absence of the system Id.
internal string DocTypeSystem {
get {
return docTypeSystem;
}
set {
CheckReadOnly("DocTypeSystem");
docTypeSystem = value;
}
}
// Public Id in doc-type declaration. Null denotes the absence of the public Id.
internal string DocTypePublic {
get {
return docTypePublic;
}
set {
CheckReadOnly("DocTypePublic");
docTypePublic = value;
}
}
// Yes for standalone="yes", No for standalone="no", and Omit for no standalone.
internal XmlStandalone Standalone {
get {
return standalone;
}
set {
CheckReadOnly("Standalone");
standalone = value;
}
}
// True if an xml declaration should automatically be output (no need to call WriteStartDocument)
internal bool AutoXmlDeclaration {
get {
return autoXmlDecl;
}
set {
CheckReadOnly("AutoXmlDeclaration");
autoXmlDecl = value;
}
}
// If TriState.Unknown, then Indent property was not explicitly set. In this case, the AutoDetect output
// method will default to Indent=true for Html and Indent=false for Xml.
internal TriState IndentInternal {
get {
return indent;
}
set {
indent = value;
}
}
internal bool IsQuerySpecific {
get {
return cdataSections.Count != 0 || docTypePublic != null ||
docTypeSystem != null || standalone == XmlStandalone.Yes;
}
}
#endif
#if !SILVERLIGHT
[ResourceConsumption(ResourceScope.Machine)]
[ResourceExposure(ResourceScope.Machine)]
internal XmlWriter CreateWriter(string outputFileName) {
if (outputFileName == null) {
throw new ArgumentNullException("outputFileName");
}
// need to clone the settigns so that we can set CloseOutput to true to make sure the stream gets closed in the end
XmlWriterSettings newSettings = this;
if (!newSettings.CloseOutput) {
newSettings = newSettings.Clone();
newSettings.CloseOutput = true;
}
FileStream fs = null;
try {
// open file stream
fs = new FileStream(outputFileName, FileMode.Create, FileAccess.Write, FileShare.Read);
// create writer
return newSettings.CreateWriter(fs);
}
catch {
if (fs != null) {
fs.Close();
}
throw;
}
}
#endif
internal XmlWriter CreateWriter(Stream output) {
if (output == null) {
throw new ArgumentNullException("output");
}
XmlWriter writer;
// create raw writer
#if SILVERLIGHT
Debug.Assert(Encoding.UTF8.WebName == "utf-8");
if (this.Encoding.WebName == "utf-8") { // Encoding.CodePage is not supported in Silverlight
// create raw UTF-8 writer
if (this.Indent) {
writer = new XmlUtf8RawTextWriterIndent(output, this);
}
else {
writer = new XmlUtf8RawTextWriter(output, this);
}
}
else {
// create raw writer for other encodings
if (this.Indent) {
writer = new XmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new XmlEncodedRawTextWriter(output, this);
}
}
#else
Debug.Assert(Encoding.UTF8.WebName == "utf-8");
if (this.Encoding.WebName == "utf-8") { // Encoding.CodePage is not supported in Silverlight
// create raw UTF-8 writer
switch (this.OutputMethod) {
case XmlOutputMethod.Xml:
if (this.Indent) {
writer = new XmlUtf8RawTextWriterIndent(output, this);
}
else {
writer = new XmlUtf8RawTextWriter(output, this);
}
break;
case XmlOutputMethod.Html:
if (this.Indent) {
writer = new HtmlUtf8RawTextWriterIndent(output, this);
}
else {
writer = new HtmlUtf8RawTextWriter(output, this);
}
break;
case XmlOutputMethod.Text:
writer = new TextUtf8RawTextWriter(output, this);
break;
case XmlOutputMethod.AutoDetect:
writer = new XmlAutoDetectWriter(output, this);
break;
default:
Debug.Assert(false, "Invalid XmlOutputMethod setting.");
return null;
}
}
else {
// Otherwise, create a general-purpose writer than can do any encoding
switch (this.OutputMethod) {
case XmlOutputMethod.Xml:
if (this.Indent) {
writer = new XmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new XmlEncodedRawTextWriter(output, this);
}
break;
case XmlOutputMethod.Html:
if (this.Indent) {
writer = new HtmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new HtmlEncodedRawTextWriter(output, this);
}
break;
case XmlOutputMethod.Text:
writer = new TextEncodedRawTextWriter(output, this);
break;
case XmlOutputMethod.AutoDetect:
writer = new XmlAutoDetectWriter(output, this);
break;
default:
Debug.Assert(false, "Invalid XmlOutputMethod setting.");
return null;
}
}
// Wrap with Xslt/XQuery specific writer if needed;
// XmlOutputMethod.AutoDetect writer does this lazily when it creates the underlying Xml or Html writer.
if (this.OutputMethod != XmlOutputMethod.AutoDetect) {
if (this.IsQuerySpecific) {
// Create QueryOutputWriter if CData sections or DocType need to be tracked
writer = new QueryOutputWriter((XmlRawWriter)writer, this);
}
}
#endif // !SILVERLIGHT
// wrap with well-formed writer
writer = new XmlWellFormedWriter(writer, this);
return writer;
}
internal XmlWriter CreateWriter(TextWriter output) {
if (output == null) {
throw new ArgumentNullException("output");
}
XmlWriter writer;
// create raw writer
#if SILVERLIGHT
if (this.Indent) {
writer = new XmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new XmlEncodedRawTextWriter(output, this);
}
#else
switch (this.OutputMethod) {
case XmlOutputMethod.Xml:
if (this.Indent) {
writer = new XmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new XmlEncodedRawTextWriter(output, this);
}
break;
case XmlOutputMethod.Html:
if (this.Indent) {
writer = new HtmlEncodedRawTextWriterIndent(output, this);
}
else {
writer = new HtmlEncodedRawTextWriter(output, this);
}
break;
case XmlOutputMethod.Text:
writer = new TextEncodedRawTextWriter(output, this);
break;
case XmlOutputMethod.AutoDetect:
writer = new XmlAutoDetectWriter(output, this);
break;
default:
Debug.Assert(false, "Invalid XmlOutputMethod setting.");
return null;
}
// XmlOutputMethod.AutoDetect writer does this lazily when it creates the underlying Xml or Html writer.
if (this.OutputMethod != XmlOutputMethod.AutoDetect) {
if (this.IsQuerySpecific) {
// Create QueryOutputWriter if CData sections or DocType need to be tracked
writer = new QueryOutputWriter((XmlRawWriter)writer, this);
}
}
#endif //SILVERLIGHT
// wrap with well-formed writer
writer = new XmlWellFormedWriter(writer, this);
return writer;
}
internal XmlWriter CreateWriter(XmlWriter output) {
if (output == null) {
throw new ArgumentNullException("output");
}
return AddConformanceWrapper(output);
}
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() {
encoding = Encoding.UTF8;
omitXmlDecl = false;
newLineHandling = NewLineHandling.Replace;
newLineChars = Environment.NewLine; // "\r\n" on Windows, "\n" on Unix
indent = TriState.Unknown;
indentChars = " ";
newLineOnAttributes = false;
closeOutput = false;
namespaceHandling = NamespaceHandling.Default;
conformanceLevel = ConformanceLevel.Document;
checkCharacters = true;
#if !SILVERLIGHT
outputMethod = XmlOutputMethod.Xml;
cdataSections.Clear();
mergeCDataSections = false;
mediaType = null;
docTypeSystem = null;
docTypePublic = null;
standalone = XmlStandalone.Omit;
#endif
isReadOnly = false;
}
private XmlWriter AddConformanceWrapper(XmlWriter baseWriter) {
ConformanceLevel confLevel = ConformanceLevel.Auto;
XmlWriterSettings baseWriterSettings = baseWriter.Settings;
bool checkValues = false;
bool checkNames = false;
bool replaceNewLines = false;
bool needWrap = false;
if (baseWriterSettings == null) {
// assume the V1 writer already do all conformance checking;
// wrap only if NewLineHandling == Replace or CheckCharacters is true
if (this.newLineHandling == NewLineHandling.Replace) {
replaceNewLines = true;
needWrap = true;
}
if (this.checkCharacters) {
checkValues = true;
needWrap = true;
}
}
else {
if (this.conformanceLevel != baseWriterSettings.ConformanceLevel) {
confLevel = this.ConformanceLevel;
needWrap = true;
}
if (this.checkCharacters && !baseWriterSettings.CheckCharacters) {
checkValues = true;
checkNames = confLevel == ConformanceLevel.Auto;
needWrap = true;
}
if (this.newLineHandling == NewLineHandling.Replace &&
baseWriterSettings.NewLineHandling == NewLineHandling.None) {
replaceNewLines = true;
needWrap = true;
}
}
XmlWriter writer = baseWriter;
if (needWrap) {
if (confLevel != ConformanceLevel.Auto) {
writer = new XmlWellFormedWriter(writer, this);
}
if (checkValues || replaceNewLines) {
writer = new XmlCharCheckingWriter(writer, checkValues, checkNames, replaceNewLines, this.NewLineChars);
}
}
#if !SILVERLIGHT
if (this.IsQuerySpecific && (baseWriterSettings == null || !baseWriterSettings.IsQuerySpecific)) {
// Create QueryOutputWriterV1 if CData sections or DocType need to be tracked
writer = new QueryOutputWriterV1(writer, this);
}
#endif
return writer;
}
//
// Internal methods
//
#if !SILVERLIGHT
#if !HIDE_XSL
///
/// Serialize the object to BinaryWriter.
///
internal void GetObjectData(XmlQueryDataWriter writer) {
// Encoding encoding;
// NOTE: For Encoding we serialize only CodePage, and ignore EncoderFallback/DecoderFallback.
// It suffices for XSLT purposes, but not in the general case.
Debug.Assert(Encoding.Equals(Encoding.GetEncoding(Encoding.CodePage)), "Cannot serialize encoding correctly");
writer.Write(Encoding.CodePage);
// bool omitXmlDecl;
writer.Write(OmitXmlDeclaration);
// NewLineHandling newLineHandling;
writer.Write((sbyte)NewLineHandling);
// string newLineChars;
writer.WriteStringQ(NewLineChars);
// TriState indent;
writer.Write((sbyte)IndentInternal);
// string indentChars;
writer.WriteStringQ(IndentChars);
// bool newLineOnAttributes;
writer.Write(NewLineOnAttributes);
// bool closeOutput;
writer.Write(CloseOutput);
// ConformanceLevel conformanceLevel;
writer.Write((sbyte)ConformanceLevel);
// bool checkCharacters;
writer.Write(CheckCharacters);
// XmlOutputMethod outputMethod;
writer.Write((sbyte)outputMethod);
// List cdataSections;
writer.Write(cdataSections.Count);
foreach (XmlQualifiedName qname in cdataSections) {
writer.Write(qname.Name);
writer.Write(qname.Namespace);
}
// bool mergeCDataSections;
writer.Write(mergeCDataSections);
// string mediaType;
writer.WriteStringQ(mediaType);
// string docTypeSystem;
writer.WriteStringQ(docTypeSystem);
// string docTypePublic;
writer.WriteStringQ(docTypePublic);
// XmlStandalone standalone;
writer.Write((sbyte)standalone);
// bool autoXmlDecl;
writer.Write(autoXmlDecl);
// bool isReadOnly;
writer.Write(ReadOnly);
}
///
/// Deserialize the object from BinaryReader.
///
internal XmlWriterSettings(XmlQueryDataReader reader) {
// Encoding encoding;
Encoding = Encoding.GetEncoding(reader.ReadInt32());
// bool omitXmlDecl;
OmitXmlDeclaration = reader.ReadBoolean();
// NewLineHandling newLineHandling;
NewLineHandling = (NewLineHandling)reader.ReadSByte(0, (sbyte)NewLineHandling.None);
// string newLineChars;
NewLineChars = reader.ReadStringQ();
// TriState indent;
IndentInternal = (TriState)reader.ReadSByte((sbyte)TriState.Unknown, (sbyte)TriState.True);
// string indentChars;
IndentChars = reader.ReadStringQ();
// bool newLineOnAttributes;
NewLineOnAttributes = reader.ReadBoolean();
// bool closeOutput;
CloseOutput = reader.ReadBoolean();
// ConformanceLevel conformanceLevel;
ConformanceLevel = (ConformanceLevel)reader.ReadSByte(0, (sbyte)ConformanceLevel.Document);
// bool checkCharacters;
CheckCharacters = reader.ReadBoolean();
// XmlOutputMethod outputMethod;
outputMethod = (XmlOutputMethod)reader.ReadSByte(0, (sbyte)XmlOutputMethod.AutoDetect);
// List cdataSections;
int length = reader.ReadInt32();
cdataSections = new List(length);
for (int idx = 0; idx < length; idx++) {
cdataSections.Add(new XmlQualifiedName(reader.ReadString(), reader.ReadString()));
}
// bool mergeCDataSections;
mergeCDataSections = reader.ReadBoolean();
// string mediaType;
mediaType = reader.ReadStringQ();
// string docTypeSystem;
docTypeSystem = reader.ReadStringQ();
// string docTypePublic;
docTypePublic = reader.ReadStringQ();
// XmlStandalone standalone;
Standalone = (XmlStandalone)reader.ReadSByte(0, (sbyte)XmlStandalone.No);
// bool autoXmlDecl;
autoXmlDecl = reader.ReadBoolean();
// bool isReadOnly;
ReadOnly = reader.ReadBoolean();
}
#else
internal void GetObjectData(object writer) { }
internal XmlWriterSettings(object reader) { }
#endif
#endif
}
}
// 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
- OleAutBinder.cs
- ListArgumentProvider.cs
- DateTimePickerDesigner.cs
- DefaultBinder.cs
- Msec.cs
- TimelineGroup.cs
- AssemblyUtil.cs
- Separator.cs
- RedistVersionInfo.cs
- SuppressMergeCheckAttribute.cs
- DefaultProxySection.cs
- ExpressionBuilder.cs
- CapabilitiesPattern.cs
- ActiveXMessageFormatter.cs
- CodeComment.cs
- StrokeNodeEnumerator.cs
- BooleanAnimationUsingKeyFrames.cs
- ColumnCollectionEditor.cs
- RegistrationServices.cs
- ImageListStreamer.cs
- IPipelineRuntime.cs
- EtwTrace.cs
- WebPartZone.cs
- ItemCollection.cs
- SettingsBase.cs
- XmlSchemaAny.cs
- RawStylusInputCustomData.cs
- ExtendedTransformFactory.cs
- NullPackagingPolicy.cs
- DataGrid.cs
- X509SubjectKeyIdentifierClause.cs
- KoreanCalendar.cs
- BuildProvidersCompiler.cs
- TextEmbeddedObject.cs
- MarkupCompiler.cs
- FormViewModeEventArgs.cs
- CacheRequest.cs
- Emitter.cs
- DbException.cs
- DataGridItem.cs
- LogStore.cs
- JsonWriter.cs
- KeyValuePair.cs
- DocobjHost.cs
- DataListItem.cs
- TreeNode.cs
- RecordsAffectedEventArgs.cs
- HttpCookieCollection.cs
- Decoder.cs
- XmlCharCheckingReader.cs
- __FastResourceComparer.cs
- RegisteredArrayDeclaration.cs
- CustomCategoryAttribute.cs
- _FtpDataStream.cs
- ListView.cs
- ActiveXSite.cs
- CheckPair.cs
- WindowsMenu.cs
- CompiledRegexRunnerFactory.cs
- OperationDescription.cs
- TreeViewDataItemAutomationPeer.cs
- Thread.cs
- GlyphRunDrawing.cs
- BinarySerializer.cs
- Rect3DValueSerializer.cs
- MILUtilities.cs
- Completion.cs
- IncrementalCompileAnalyzer.cs
- PartialClassGenerationTask.cs
- contentDescriptor.cs
- HttpSessionStateWrapper.cs
- ZipIOFileItemStream.cs
- InfiniteTimeSpanConverter.cs
- ImageFormat.cs
- WorkflowCompensationBehavior.cs
- HttpRuntime.cs
- MemoryFailPoint.cs
- AssemblyBuilder.cs
- AutoGeneratedFieldProperties.cs
- DrawListViewColumnHeaderEventArgs.cs
- DetailsViewDeleteEventArgs.cs
- XmlSchemaCompilationSettings.cs
- PresentationTraceSources.cs
- WebServiceTypeData.cs
- diagnosticsswitches.cs
- HyperLinkField.cs
- CodePageUtils.cs
- CodeValidator.cs
- UTF8Encoding.cs
- BitmapEffectState.cs
- XmlFormatWriterGenerator.cs
- SqlDependency.cs
- Console.cs
- Comparer.cs
- DefaultObjectMappingItemCollection.cs
- CustomPopupPlacement.cs
- MobileComponentEditorPage.cs
- EntityDataSourceConfigureObjectContextPanel.cs
- Char.cs
- AssemblyAttributesGoHere.cs