public MwsXmlBuilder(bool toWrap, ConformanceLevel conformanceLevel) { builder = new StringBuilder(); XmlWriterSettings settings = new XmlWriterSettings(); settings.OmitXmlDeclaration = !toWrap; settings.ConformanceLevel = conformanceLevel; writer = XmlWriter.Create(builder, settings); }
private static void CheckReaderSettings(XmlReaderSettings settings, ConformanceLevel expectedConformanceLevel) { Assert.IsFalse(settings.CheckCharacters); #if NET_4_0 && !__MonoCS__ Assert.AreEqual(DtdProcessing.Parse, settings.DtdProcessing); #else Assert.IsTrue(settings.ProhibitDtd); #endif Assert.AreEqual(ValidationType.None , settings.ValidationType); Assert.IsTrue(settings.CloseInput); Assert.IsTrue(settings.IgnoreWhitespace); Assert.AreEqual(expectedConformanceLevel, settings.ConformanceLevel); }
private XmlWriterSettings(XmlWriterSettings org) { checkCharacters = org.checkCharacters; closeOutput = org.closeOutput; conformance = org.conformance; encoding = org.encoding; indent = org.indent; indentChars = org.indentChars; newLineChars = org.newLineChars; newLineOnAttributes = org.newLineOnAttributes; newLineHandling = org.newLineHandling; normalizeNewLines = org.normalizeNewLines; outputMethod = org.outputMethod; omitXmlDeclaration = org.omitXmlDeclaration; }
public void Reset() { checkCharacters = true; closeOutput = false; conformance = ConformanceLevel.Document; encoding = Encoding.UTF8; indent = false; indentChars = " "; newLineChars = Environment.NewLine; newLineOnAttributes = false; newLineHandling = NewLineHandling.Replace; normalizeNewLines = true; omitXmlDeclaration = false; outputMethod = XmlOutputMethod.AutoDetect; }
public void Reset () { checkCharacters = true; closeOutput = false; // ? not documented conformance = ConformanceLevel.Document; encoding = Encoding.UTF8; indent = false; indentChars = " "; // LAMESPEC: MS.NET says it is "\r\n", but it is silly decision. newLineChars = Environment.NewLine; newLineOnAttributes = false; newLineHandling = NewLineHandling.None; omitXmlDeclaration = false; outputMethod = XmlOutputMethod.AutoDetect; }
public void Reset () { checkCharacters = true; closeOutput = false; // ? not documented conformance = ConformanceLevel.Document; encoding = Encoding.UTF8; indent = false; indentChars = " "; newLineChars = "\r\n"; newLineOnAttributes = false; newLineHandling = NewLineHandling.Replace; omitXmlDeclaration = false; outputMethod = XmlOutputMethod.AutoDetect; #if NET_4_5 isAsync = false; #endif }
///<summary> /// Return an XmlReaderSettings suitable for use in Chorus applications. ///</summary> /// <remarks> /// This formats with: /// CheckCharacters as 'false', /// ProhibitDtd as 'true', /// ValidationType as ValidationType.None, /// CloseInput as 'true', /// IgnoreWhitespace as 'true', and /// ConformanceLevel as 'conformanceLevel' parameter. /// </remarks> /// <param name="conformanceLevel">Document|Fragment</param> ///<returns>XmlReaderSettings</returns> public static XmlReaderSettings CreateXmlReaderSettings(ConformanceLevel conformanceLevel) { var settings = new XmlReaderSettings { CheckCharacters = false, ConformanceLevel = conformanceLevel, #if NET_4_0 && !__MonoCS__ DtdProcessing = DtdProcessing.Parse, #else ProhibitDtd = true, #endif ValidationType = ValidationType.None, CloseInput = true, IgnoreWhitespace = true }; return settings; }
///<summary> /// Return an XmlWriterSettings suitable for use in Chorus applications. ///</summary> /// <remarks> /// This formats with new line on attributes, indents with tab, and encoded in UTF8 with no BOM. /// </remarks> /// <param name="conformanceLevel">Document|Fragment</param> ///<returns>XmlWriterSettings</returns> public static XmlWriterSettings CreateXmlWriterSettings(ConformanceLevel conformanceLevel) { var settings = new XmlWriterSettings { NewLineOnAttributes = true, // New line for each attribute, saves space on a typical Chorus changeset. Indent = true, // Indent entities IndentChars = "\t", // Tabs for the indent CheckCharacters = false, Encoding = new UTF8Encoding(false), // UTF8 without a BOM. CloseOutput = true, // Close the underlying stream on Close. This is not the default. ConformanceLevel = conformanceLevel, NewLineChars = "\r\n", // Use /r/n for our end of lines NewLineHandling = NewLineHandling.None, // Assume that the input is as written /r/n OmitXmlDeclaration = false // The default, an xml declaration is written }; return settings; }
public void Reset () { checkCharacters = true; closeInput = false; // ? not documented conformance = ConformanceLevel.Document; ignoreComments = false; ignoreProcessingInstructions = false; ignoreWhitespace = false; lineNumberOffset = 0; linePositionOffset = 0; prohibitDtd = true; #if MOONLIGHT xmlResolver = new XmlXapResolver (); #else schemas = null; schemasNeedsInitialization = true; validationFlags = XsValidationFlags.ProcessIdentityConstraints | XsValidationFlags.AllowXmlAttributes; validationType = ValidationType.None; xmlResolver = new XmlUrlResolver (); #endif }
public bool Validate(Stream stream, ConformanceLevel conformanceLevel = ConformanceLevel.Auto) { return(InternalValidate(stream, conformanceLevel)); }
// // Private methods // private void Initialize() { _nameTable = null; _lineNumberOffset = 0; _linePositionOffset = 0; _checkCharacters = true; _conformanceLevel = ConformanceLevel.Document; _ignoreWhitespace = false; _ignorePIs = false; _ignoreComments = false; _dtdProcessing = DtdProcessing.Prohibit; _closeInput = false; _maxCharactersFromEntities = 0; _maxCharactersInDocument = 0; _useAsync = false; _isReadOnly = false; }
// // Public methods // public void Reset() { nameTable = null; lineNumberOffset = 0; linePositionOffset = 0; checkCharacters = true; conformanceLevel = ConformanceLevel.Document; ignoreWhitespace = false; ignorePIs = false; ignoreComments = false; closeInput = false; isReadOnly = false; }
// Called before a root element is written (before the WriteStartElement call) // the conformanceLevel specifies the current conformance level the writer is operating with. internal virtual void OnRootElement(ConformanceLevel conformanceLevel) { }
public virtual XmlWriter CreateWriter(ConformanceLevel cl) { return this.XmlWriterTestModule.WriterFactory.CreateWriter(cl); }
internal override void OnRootElement(ConformanceLevel currentConformanceLevel) { // Just remember the current conformance level conformanceLevel = currentConformanceLevel; }
private static XmlWriter AddConformanceWrapper(XmlWriter baseWriter, XmlWriterSettings baseWriterSettings, XmlWriterSettings settings) { ConformanceLevel confLevel = ConformanceLevel.Auto; 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 (settings.NewLineHandling == NewLineHandling.Replace) { replaceNewLines = true; needWrap = true; } if (settings.CheckCharacters) { checkValues = true; needWrap = true; } } else { if (settings.ConformanceLevel != baseWriterSettings.ConformanceLevel) { confLevel = settings.ConformanceLevel; needWrap = true; } if (settings.CheckCharacters && !baseWriterSettings.CheckCharacters) { checkValues = true; checkNames = confLevel == ConformanceLevel.Auto; needWrap = true; } if (settings.NewLineHandling == NewLineHandling.Replace && baseWriterSettings.NewLineHandling == NewLineHandling.None) { replaceNewLines = true; needWrap = true; } } if (needWrap) { XmlWriter writer = baseWriter; if (confLevel != ConformanceLevel.Auto) { writer = new XmlWellFormedWriter(writer, settings); } if (checkValues || replaceNewLines) { writer = new XmlCharCheckingWriter(writer, checkValues, checkNames, replaceNewLines, settings.NewLineChars); } return(writer); } else { return(baseWriter); } }
// // Public methods // public void Reset() { CheckReadOnly( "Reset" ); nameTable = null; xmlResolver = new XmlUrlResolver(); lineNumberOffset = 0; linePositionOffset = 0; checkCharacters = true; conformanceLevel = ConformanceLevel.Document; schemas = null; validationType = ValidationType.None; validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints; validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes; ignoreWhitespace = false; ignorePIs = false; ignoreComments = false; prohibitDtd = true; closeInput = false; isReadOnly = false; }
public virtual XmlWriter CreateWriter(ConformanceLevel cl) { return(this.XmlWriterTestModule.WriterFactory.CreateWriter(cl)); }
public virtual XmlWriter CreateWriter(ConformanceLevel cl) { return(WriterFactory.CreateWriter(cl)); }
// // Constructor & finalizer // internal XmlWellFormedWriter(XmlWriter writer, XmlWriterSettings settings) { Debug.Assert(writer != null); Debug.Assert(settings != null); Debug.Assert(MaxNamespacesWalkCount <= 3); this.writer = writer; rawWriter = writer as XmlRawWriter; predefinedNamespaces = writer as IXmlNamespaceResolver; if (rawWriter != null) { rawWriter.NamespaceResolver = new NamespaceResolverProxy(this); } checkCharacters = settings.CheckCharacters; conformanceLevel = settings.ConformanceLevel; stateTable = (conformanceLevel == ConformanceLevel.Document) ? StateTableDocument : StateTableAuto; currentState = State.Start; nsStack = new Namespace[NamespaceStackInitialSize]; nsStack[0].Set("xmlns", XmlReservedNs.NsXmlNs, NamespaceKind.Special); nsStack[1].Set("xml", XmlReservedNs.NsXml, NamespaceKind.Special); if (predefinedNamespaces == null) { nsStack[2].Set(string.Empty, string.Empty, NamespaceKind.Implied); } else { string defaultNs = predefinedNamespaces.LookupNamespace(string.Empty); nsStack[2].Set(string.Empty, (defaultNs == null ? string.Empty : defaultNs), NamespaceKind.Implied); } nsTop = 2; elemScopeStack = new ElementScope[ElementStackInitialSize]; elemScopeStack[0].Set(string.Empty, string.Empty, string.Empty, nsTop); elemScopeStack[0].xmlSpace = XmlSpace.None; elemScopeStack[0].xmlLang = null; elemTop = 0; attrStack = new AttrName[AttributeArrayInitialSize]; attrValue = new StringBuilder(); hasher = new SecureStringHasher(); }
public override void WriteDocType(string name, string pubid, string sysid, string subset) { try { if (name == null || name.Length == 0) { throw new ArgumentException(Res.GetString(Res.Xml_EmptyName)); } XmlConvert.VerifyQName(name); if (conformanceLevel == ConformanceLevel.Fragment) { throw new InvalidOperationException(Res.GetString(Res.Xml_DtdNotAllowedInFragment)); } AdvanceState(Token.Dtd); if (dtdWritten) { currentState = State.Error; throw new InvalidOperationException(Res.GetString(Res.Xml_DtdAlreadyWritten)); } if (conformanceLevel == ConformanceLevel.Auto) { conformanceLevel = ConformanceLevel.Document; stateTable = StateTableDocument; } int i; // check characters if (checkCharacters) { if (pubid != null) { if ((i = xmlCharType.IsPublicId(pubid)) >= 0) { throw new ArgumentException(Res.GetString(Res.Xml_InvalidCharacter, XmlException.BuildCharExceptionStr(pubid[i])), "pubid"); } } if (sysid != null) { if ((i = xmlCharType.IsOnlyCharData(sysid)) >= 0) { throw new ArgumentException(Res.GetString(Res.Xml_InvalidCharacter, XmlException.BuildCharExceptionStr(sysid[i])), "sysid"); } } if (subset != null) { if ((i = xmlCharType.IsOnlyCharData(subset)) >= 0) { throw new ArgumentException(Res.GetString(Res.Xml_InvalidCharacter, XmlException.BuildCharExceptionStr(subset[i])), "subset"); } } } // write doctype writer.WriteDocType(name, pubid, sysid, subset); dtdWritten = true; } catch { currentState = State.Error; throw; } }
private void WriteStartDocumentImpl(XmlStandalone standalone) { try { AdvanceState(Token.StartDocument); if (conformanceLevel == ConformanceLevel.Auto) { conformanceLevel = ConformanceLevel.Document; stateTable = StateTableDocument; } else if (conformanceLevel == ConformanceLevel.Fragment) { throw new InvalidOperationException(Res.GetString(Res.Xml_CannotStartDocumentOnFragment)); } if (rawWriter != null) { if (!xmlDeclFollows) { rawWriter.WriteXmlDeclaration(standalone); } } else { // We do not pass the standalone value here - Dev10 Bug #479769 writer.WriteStartDocument(); } } catch { currentState = State.Error; throw; } }
// // Private methods // private 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; _writeEndDocumentOnClose = true; _outputMethod = XmlOutputMethod.Xml; _cdataSections.Clear(); _mergeCDataSections = false; _mediaType = null; _docTypeSystem = null; _docTypePublic = null; _standalone = XmlStandalone.Omit; _doNotEscapeUriAttributes = false; _useAsync = false; _isReadOnly = false; }
public static string Serialize <T>(object data, bool omitXmlDeclaration = true, ConformanceLevel conformanceLevel = ConformanceLevel.Auto, Encoding encoding = null, bool formatOutputIndented = true, bool omitXmlNamespace = true) { if (string.IsNullOrWhiteSpace(data?.ToString())) { return(null); } if (encoding == null) { encoding = Encoding.UTF8; } // handle the output stream XmlWriterSettings settings = new XmlWriterSettings() { OmitXmlDeclaration = omitXmlDeclaration, ConformanceLevel = conformanceLevel, Encoding = encoding, CloseOutput = true, Indent = formatOutputIndented }; XmlSerializer s = new XmlSerializer(typeof(T)); StringBuilder buf = new StringBuilder(); XmlWriter w = XmlWriter.Create(buf, settings); if (data is XmlDocument) { ((XmlDocument)data).Save(w); } else { if (omitXmlNamespace) { XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", ""); s.Serialize(w, data, ns); } else { s.Serialize(w, data); } } w.Close(); return(buf.ToString()); }
// // 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; writeEndDocumentOnClose = true; #if !SILVERLIGHT outputMethod = XmlOutputMethod.Xml; cdataSections.Clear(); mergeCDataSections = false; mediaType = null; docTypeSystem = null; docTypePublic = null; standalone = XmlStandalone.Omit; doNotEscapeUriAttributes = false; #endif #if ASYNC || FEATURE_NETCORE useAsync = false; #endif isReadOnly = false; }
private List<XmlWriter> GetXmlWriters(Encoding encoding, ConformanceLevel conformanceLevel) { var xmlWriters = new List<XmlWriter>(); int count = 0; var s = new XmlWriterSettings(); s.CheckCharacters = true; s.Encoding = encoding; var ws = new XmlWriterSettings(); ws.CheckCharacters = false; // Set it to true when FileIO is ok ws.CloseOutput = false; ws.Encoding = encoding; s.ConformanceLevel = conformanceLevel; ws.ConformanceLevel = conformanceLevel; TextWriter tw = new StreamWriter(FilePathUtil.getStream(GenerateTestFileName(count++))); xmlWriters.Add(new CoreXml.Test.XLinq.CustomWriter(tw, ws)); // CustomWriter xmlWriters.Add(XmlWriter.Create(FilePathUtil.getStream(GenerateTestFileName(count++)), s)); // Factory XmlWriter xmlWriters.Add(XmlWriter.Create(FilePathUtil.getStream(GenerateTestFileName(count++)), ws)); // Factory Writer return xmlWriters; }
public XmlParsingOptions() { this.ConformanceLevel = ConformanceLevel.Document; this.XmlResolver = new XmlDynamicResolver(Assembly.GetCallingAssembly()); }
/// <summary> /// 以UTF8编码方式编写XML。 /// </summary> /// <param name="writeAction">编写操作。</param> /// <param name="indent">是否缩进。</param> /// <param name="conformanceLevel">指示XML是文档还是片段。</param> /// <returns>XML 字符串。</returns> public static string WriteUtf8Xml(Action <XmlWriter> writeAction, bool indent = true, ConformanceLevel conformanceLevel = ConformanceLevel.Document) { XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = indent; settings.ConformanceLevel = conformanceLevel; settings.Encoding = Encoding.UTF8; using (MemoryStream stream = new MemoryStream()) { using (XmlWriter writer = XmlWriter.Create(stream, settings)) { if (writeAction != null) { writeAction.Invoke(writer); } byte[] content = stream.ToArray(); string xml = Encoding.UTF8.GetString(content, 0, content.Length); return(xml); } } }
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 (_newLineHandling == NewLineHandling.Replace) { replaceNewLines = true; needWrap = true; } if (_checkCharacters) { checkValues = true; needWrap = true; } } else { if (_conformanceLevel != baseWriterSettings.ConformanceLevel) { confLevel = this.ConformanceLevel; needWrap = true; } if (_checkCharacters && !baseWriterSettings.CheckCharacters) { checkValues = true; checkNames = confLevel == ConformanceLevel.Auto; needWrap = true; } if (_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 (this.IsQuerySpecific && (baseWriterSettings == null || !baseWriterSettings.IsQuerySpecific)) { // Create QueryOutputWriterV1 if CData sections or DocType need to be tracked writer = new QueryOutputWriterV1(writer, this); } return(writer); }
private void WriteStartDocumentImpl(XmlStandalone standalone) { try { AdvanceState(Token.StartDocument); if (_conformanceLevel == ConformanceLevel.Auto) { _conformanceLevel = ConformanceLevel.Document; _stateTable = s_stateTableDocument; } else if (_conformanceLevel == ConformanceLevel.Fragment) { throw new InvalidOperationException(SR.Xml_CannotStartDocumentOnFragment); } if (_rawWriter != null) { if (!_xmlDeclFollows) { _rawWriter.WriteXmlDeclaration(standalone); } } else { // We do not pass the standalone value here _writer.WriteStartDocument(); } } catch { _currentState = State.Error; throw; } }
// // Constructor & finalizer // internal XmlWellFormedWriter(XmlWriter writer, XmlWriterSettings settings) { Debug.Assert(writer != null); Debug.Assert(settings != null); Debug.Assert(MaxNamespacesWalkCount <= 3); _writer = writer; _rawWriter = writer as XmlRawWriter; _predefinedNamespaces = writer as IXmlNamespaceResolver; if (_rawWriter != null) { _rawWriter.NamespaceResolver = new NamespaceResolverProxy(this); } _checkCharacters = settings.CheckCharacters; _omitDuplNamespaces = (settings.NamespaceHandling & NamespaceHandling.OmitDuplicates) != 0; _writeEndDocumentOnClose = settings.WriteEndDocumentOnClose; _conformanceLevel = settings.ConformanceLevel; _stateTable = (_conformanceLevel == ConformanceLevel.Document) ? s_stateTableDocument : s_stateTableAuto; _currentState = State.Start; _nsStack = new Namespace[NamespaceStackInitialSize]; _nsStack[0].Set("xmlns", XmlReservedNs.NsXmlNs, NamespaceKind.Special); _nsStack[1].Set("xml", XmlReservedNs.NsXml, NamespaceKind.Special); if (_predefinedNamespaces == null) { _nsStack[2].Set(string.Empty, string.Empty, NamespaceKind.Implied); } else { string defaultNs = _predefinedNamespaces.LookupNamespace(string.Empty); _nsStack[2].Set(string.Empty, (defaultNs == null ? string.Empty : defaultNs), NamespaceKind.Implied); } _nsTop = 2; _elemScopeStack = new ElementScope[ElementStackInitialSize]; _elemScopeStack[0].Set(string.Empty, string.Empty, string.Empty, _nsTop); _elemScopeStack[0].xmlSpace = XmlSpace.None; _elemScopeStack[0].xmlLang = null; _elemTop = 0; _attrStack = new AttrName[AttributeArrayInitialSize]; _hasher = new SecureStringHasher(); }
private void Initialize(XmlResolver resolver) { _nameTable = null; if (!EnableLegacyXmlSettings()) { _xmlResolver = resolver; // limit the entity resolving to 10 million character. the caller can still // override it to any other value or set it to zero for unlimiting it _maxCharactersFromEntities = (long)1e7; } else { _xmlResolver = (resolver == null ? CreateDefaultResolver() : resolver); _maxCharactersFromEntities = 0; } _lineNumberOffset = 0; _linePositionOffset = 0; _checkCharacters = true; _conformanceLevel = ConformanceLevel.Document; _ignoreWhitespace = false; _ignorePIs = false; _ignoreComments = false; _dtdProcessing = DtdProcessing.Prohibit; _closeInput = false; _maxCharactersInDocument = 0; _schemas = null; _validationType = ValidationType.None; _validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints; _validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes; _useAsync = false; _isReadOnly = false; IsXmlResolverSet = false; }
void Initialize(XmlResolver resolver) { nameTable = null; #if !SILVERLIGHT if (!EnableLegacyXmlSettings()) { xmlResolver = resolver; // limit the entity resolving to 10 million character. the caller can still // override it to any other value or set it to zero for unlimiting it maxCharactersFromEntities = (long) 1e7; } else #endif { xmlResolver = (resolver == null ? CreateDefaultResolver() : resolver); maxCharactersFromEntities = 0; } lineNumberOffset = 0; linePositionOffset = 0; checkCharacters = true; conformanceLevel = ConformanceLevel.Document; ignoreWhitespace = false; ignorePIs = false; ignoreComments = false; dtdProcessing = DtdProcessing.Prohibit; closeInput = false; maxCharactersInDocument = 0; #if !SILVERLIGHT schemas = null; validationType = ValidationType.None; validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints; validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes; #endif #if ASYNC || FEATURE_NETCORE useAsync = false; #endif isReadOnly = false; #if !SILVERLIGHT IsXmlResolverSet = false; #endif }
public static XmlReaderSettings CreateSettings(ConformanceLevel level, DtdProcessing dtdProcessing, XmlUrlResolver resolver, XmlSchemaValidationFlags validationFlags, ValidationType validationType, XmlSchemaSet schemaSet, ValidationEventHandler onErrorHandler) { return(CreateSettings(false, false, true, false, level, dtdProcessing, resolver, validationFlags, validationType, schemaSet, onErrorHandler)); }
static XmlReaderSettings CreateReaderSettings(XamlXmlReaderSettings settings, ConformanceLevel conformance = ConformanceLevel.Document, bool?closeInput = null) { return(new XmlReaderSettings { CloseInput = closeInput ?? settings?.CloseInput ?? false, IgnoreComments = true, IgnoreProcessingInstructions = true, ConformanceLevel = conformance }); }
public XPathSerializationOptions() { this.ConformanceLevel = ConformanceLevel.Auto; }
private void StartFragment() { _conformanceLevel = ConformanceLevel.Fragment; Debug.Assert(_stateTable == s_stateTableAuto); }
void Initialize(XmlResolver resolver) { nameTable = null; xmlResolver = (resolver == null ? CreateDefaultResolver() : resolver); 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 #if ASYNC || FEATURE_NETCORE useAsync = false; #endif isReadOnly = false; #if !SILVERLIGHT IsXmlResolverSet = false; #endif }
public override void WriteDocType(string name, string pubid, string sysid, string subset) { try { if (name == null || name.Length == 0) { throw new ArgumentException(SR.Xml_EmptyName); } XmlConvert.VerifyQName(name, ExceptionType.XmlException); if (_conformanceLevel == ConformanceLevel.Fragment) { throw new InvalidOperationException(SR.Xml_DtdNotAllowedInFragment); } AdvanceState(Token.Dtd); if (_dtdWritten) { _currentState = State.Error; throw new InvalidOperationException(SR.Xml_DtdAlreadyWritten); } if (_conformanceLevel == ConformanceLevel.Auto) { _conformanceLevel = ConformanceLevel.Document; _stateTable = s_stateTableDocument; } int i; // check characters if (_checkCharacters) { if (pubid != null) { if ((i = _xmlCharType.IsPublicId(pubid)) >= 0) { throw new ArgumentException(SR.Format(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(pubid, i)), nameof(pubid)); } } if (sysid != null) { if ((i = _xmlCharType.IsOnlyCharData(sysid)) >= 0) { throw new ArgumentException(SR.Format(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(sysid, i)), nameof(sysid)); } } if (subset != null) { if ((i = _xmlCharType.IsOnlyCharData(subset)) >= 0) { throw new ArgumentException(SR.Format(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(subset, i)), nameof(subset)); } } } // write doctype _writer.WriteDocType(name, pubid, sysid, subset); _dtdWritten = true; } catch { _currentState = State.Error; throw; } }
internal override void OnRootElement(ConformanceLevel currentConformanceLevel) { this.conformanceLevel = currentConformanceLevel; }
public XmlSerializationOptions() { this.ConformanceLevel = ConformanceLevel.Auto; }
public static XmlReaderSettings CreateSettings(ConformanceLevel level, DtdProcessing dtdProcessing, XmlUrlResolver resolver, XmlSchemaValidationFlags validationFlags, ValidationType validationType) { return(CreateSettings(false, false, true, false, level, dtdProcessing, resolver, validationFlags, validationType, null, null)); }