Change from XmlTextReader to XmlReader. (#828)

H1Gdev · web-flow · commit fa3b8680e640 · 2021-02-18T21:08:11.000+01:00
* Change from XmlTextReader to XmlReader * related to #90
diff --git a/Source/Metadata/SvgDocumentMetadata.cs b/Source/Metadata/SvgDocumentMetadata.cs
@@ -35,7 +35,7 @@ public override SvgElement DeepCopy()
             return DeepCopy<SvgDocumentMetadata>();
         }
 
-        public override void InitialiseFromXML(XmlTextReader reader, SvgDocument document)
+        public override void InitialiseFromXML(XmlReader reader, SvgDocument document)
         {
             base.InitialiseFromXML(reader, document);
 
diff --git a/Source/SvgElement.cs b/Source/SvgElement.cs
@@ -568,7 +568,7 @@ void Attributes_AttributeChanged(object sender, AttributeEventArgs e)
             OnAttributeChanged(e);
         }
 
-        public virtual void InitialiseFromXML(XmlTextReader reader, SvgDocument document)
+        public virtual void InitialiseFromXML(XmlReader reader, SvgDocument document)
         {
             throw new NotImplementedException();
         }
@@ -963,7 +963,7 @@ private bool TryResolveParentAttributeValue(string attributeKey, out object pare
         /// <remarks>
         /// Recommendation is to create an XmlWriter by calling a factory method,<br/>
         /// e.g. <see cref="XmlWriter.Create(System.IO.Stream)"/>,
-        /// as per <a href="https://docs.microsoft.com/dotnet/api/system.xml.xmltextreader#remarks">Microsoft documentation</a>.<br/>
+        /// as per <a href="https://docs.microsoft.com/dotnet/api/system.xml.xmltextwriter#remarks">Microsoft documentation</a>.<br/>
         /// <br/>
         /// However, unlike an <see cref="XmlTextWriter"/> created via 'new XmlTextWriter()',<br/>
         /// a factory-constructed XmlWriter will not flush output until it is closed<br/>
diff --git a/Source/SvgElementFactory.cs b/Source/SvgElementFactory.cs
@@ -64,9 +64,9 @@ where t.GetCustomAttributes(typeof(SvgElementAttribute), true).Length > 0
         internal Dictionary<string, List<Type>> AvailableElementsDictionary => availableElementsDictionary;
 
         /// <summary>
-        /// Creates an <see cref="SvgDocument"/> from the current node in the specified <see cref="XmlTextReader"/>.
+        /// Creates an <see cref="SvgDocument"/> from the current node in the specified <see cref="XmlReader"/>.
         /// </summary>
-        /// <param name="reader">The <see cref="XmlTextReader"/> containing the node to parse into an <see cref="SvgDocument"/>.</param>
+        /// <param name="reader">The <see cref="XmlReader"/> containing the node to parse into an <see cref="SvgDocument"/>.</param>
         /// <exception cref="ArgumentNullException">The <paramref name="reader"/> parameter cannot be <c>null</c>.</exception>
         /// <exception cref="InvalidOperationException">The CreateDocument method can only be used to parse root &lt;svg&gt; elements.</exception>
         public T CreateDocument<T>(XmlReader reader) where T : SvgDocument, new()
@@ -85,9 +85,9 @@ where t.GetCustomAttributes(typeof(SvgElementAttribute), true).Length > 0
         }
 
         /// <summary>
-        /// Creates an <see cref="SvgElement"/> from the current node in the specified <see cref="XmlTextReader"/>.
+        /// Creates an <see cref="SvgElement"/> from the current node in the specified <see cref="XmlReader"/>.
         /// </summary>
-        /// <param name="reader">The <see cref="XmlTextReader"/> containing the node to parse into a subclass of <see cref="SvgElement"/>.</param>
+        /// <param name="reader">The <see cref="XmlReader"/> containing the node to parse into a subclass of <see cref="SvgElement"/>.</param>
         /// <param name="document">The <see cref="SvgDocument"/> that the created element belongs to.</param>
         /// <exception cref="ArgumentNullException">The <paramref name="reader"/> and <paramref name="document"/> parameters cannot be <c>null</c>.</exception>
         public SvgElement CreateElement(XmlReader reader, SvgDocument document)
diff --git a/Source/SvgNodeReader.cs b/Source/SvgNodeReader.cs
@@ -6,7 +6,7 @@ namespace Svg
 {
     internal sealed class SvgNodeReader : XmlNodeReader
     {
-        private Dictionary<string, string> _entities;
+        private readonly Dictionary<string, string> _entities;
         private string _value;
         private bool _customValue = false;
         private string _localName;
@@ -21,13 +21,10 @@ public SvgNodeReader(XmlNode node, Dictionary<string, string> entities)
         /// Gets the text value of the current node.
         /// </summary>
         /// <value></value>
-        /// <returns>The value returned depends on the <see cref="P:System.Xml.XmlTextReader.NodeType"/> of the node. The following table lists node types that have a value to return. All other node types return String.Empty.Node Type Value AttributeThe value of the attribute. CDATAThe content of the CDATA section. CommentThe content of the comment. DocumentTypeThe internal subset. ProcessingInstructionThe entire content, excluding the target. SignificantWhitespaceThe white space within an xml:space= 'preserve' scope. TextThe content of the text node. WhitespaceThe white space between markup. XmlDeclarationThe content of the declaration. </returns>
+        /// <returns>The value returned depends on the <see cref="P:System.Xml.XmlNodeReader.NodeType"/> of the node. The following table lists node types that have a value to return. All other node types return String.Empty.Node Type Value AttributeThe value of the attribute. CDATAThe content of the CDATA section. CommentThe content of the comment. DocumentTypeThe internal subset. ProcessingInstructionThe entire content, excluding the target. SignificantWhitespaceThe white space within an xml:space= 'preserve' scope. TextThe content of the text node. WhitespaceThe white space between markup. XmlDeclarationThe content of the declaration. </returns>
         public override string Value
         {
-            get
-            {
-                return _customValue ? _value : base.Value;
-            }
+            get { return _customValue ? _value : base.Value; }
         }
 
         /// <summary>
@@ -37,10 +34,7 @@ public override string Value
         /// <returns>The name of the current node with the prefix removed. For example, LocalName is book for the element &lt;bk:book&gt;.For node types that do not have a name (like Text, Comment, and so on), this property returns String.Empty.</returns>
         public override string LocalName
         {
-            get
-            {
-                return _customValue ? _localName : base.LocalName;
-            }
+            get { return _customValue ? _localName : base.LocalName; }
         }
 
         /// <summary>
@@ -60,13 +54,9 @@ public override bool MoveToNextAttribute()
                 if (ReadAttributeValue())
                 {
                     if (NodeType == XmlNodeType.EntityReference)
-                    {
                         ResolveEntity();
-                    }
                     else
-                    {
                         _value = base.Value;
-                    }
                 }
                 _customValue = true;
             }
@@ -87,31 +77,24 @@ public override bool Read()
             bool read = base.Read();
 
             if (NodeType == XmlNodeType.DocumentType)
-            {
                 ParseEntities();
-            }
 
             return read;
         }
 
         private void ParseEntities()
         {
             const string entityText = "<!ENTITY";
-            string[] entities = Value.Split(new string[] { entityText }, StringSplitOptions.None);
-            string[] parts = null;
-            string name = null;
-            string value = null;
+            var entities = Value.Split(new string[] { entityText }, StringSplitOptions.None);
 
-            foreach (string entity in entities)
+            foreach (var entity in entities)
             {
                 if (string.IsNullOrEmpty(entity.Trim()))
-                {
                     continue;
-                }
 
-                parts = entity.Trim().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
-                name = parts[0];
-                value = parts[1].Split(new char[] { QuoteChar }, StringSplitOptions.RemoveEmptyEntries)[0];
+                var parts = entity.Trim().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
+                var name = parts[0];
+                var value = parts[1].Split(new char[] { QuoteChar }, StringSplitOptions.RemoveEmptyEntries)[0];
 
                 _entities.Add(name, value);
             }
diff --git a/Source/SvgTextReader.cs b/Source/SvgTextReader.cs
@@ -1,16 +1,13 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Xml;
 using System.IO;
-using System.Collections.Specialized;
+using System.Xml;
 
 namespace Svg
 {
     internal sealed class SvgTextReader : XmlTextReader
     {
-        private Dictionary<string, string> _entities;
+        private readonly Dictionary<string, string> _entities;
         private string _value;
         private bool _customValue = false;
         private string _localName;
@@ -19,16 +16,16 @@ public SvgTextReader(Stream stream, Dictionary<string, string> entities)
             : base(stream)
         {
             if (entities == null)
-                this.EntityHandling = EntityHandling.ExpandEntities;
-            this._entities = entities;
+                EntityHandling = EntityHandling.ExpandEntities;
+            _entities = entities ?? new Dictionary<string, string>();
         }
 
         public SvgTextReader(TextReader reader, Dictionary<string, string> entities)
             : base(reader)
         {
             if (entities == null)
-                this.EntityHandling = EntityHandling.ExpandEntities;
-            this._entities = entities;
+                EntityHandling = EntityHandling.ExpandEntities;
+            _entities = entities ?? new Dictionary<string, string>();
         }
 
         /// <summary>
@@ -38,10 +35,7 @@ public SvgTextReader(TextReader reader, Dictionary<string, string> entities)
         /// <returns>The value returned depends on the <see cref="P:System.Xml.XmlTextReader.NodeType"/> of the node. The following table lists node types that have a value to return. All other node types return String.Empty.Node Type Value AttributeThe value of the attribute. CDATAThe content of the CDATA section. CommentThe content of the comment. DocumentTypeThe internal subset. ProcessingInstructionThe entire content, excluding the target. SignificantWhitespaceThe white space within an xml:space= 'preserve' scope. TextThe content of the text node. WhitespaceThe white space between markup. XmlDeclarationThe content of the declaration. </returns>
         public override string Value
         {
-            get
-            {
-                return (this._customValue) ? this._value : base.Value;
-            }
+            get { return _customValue ? _value : base.Value; }
         }
 
         /// <summary>
@@ -51,23 +45,7 @@ public override string Value
         /// <returns>The name of the current node with the prefix removed. For example, LocalName is book for the element &lt;bk:book&gt;.For node types that do not have a name (like Text, Comment, and so on), this property returns String.Empty.</returns>
         public override string LocalName
         {
-            get
-            {
-                return (this._customValue) ? this._localName : base.LocalName;
-            }
-        }
-
-        private IDictionary<string, string> Entities
-        {
-            get
-            {
-                if (this._entities == null)
-                {
-                    this._entities = new Dictionary<string, string>();
-                }
-
-                return this._entities;
-            }
+            get { return _customValue ? _localName : base.LocalName; }
         }
 
         /// <summary>
@@ -82,20 +60,16 @@ public override bool MoveToNextAttribute()
 
             if (moved)
             {
-                this._localName = base.LocalName;
+                _localName = base.LocalName;
 
-                if (this.ReadAttributeValue())
+                if (ReadAttributeValue())
                 {
-                    if (this.NodeType == XmlNodeType.EntityReference)
-                    {
-                        this.ResolveEntity();
-                    }
+                    if (NodeType == XmlNodeType.EntityReference)
+                        ResolveEntity();
                     else
-                    {
-                        this._value = base.Value;
-                    }
+                        _value = base.Value;
                 }
-                this._customValue = true;
+                _customValue = true;
             }
 
             return moved;
@@ -110,39 +84,32 @@ public override bool MoveToNextAttribute()
         /// <exception cref="T:System.Xml.XmlException">An error occurred while parsing the XML. </exception>
         public override bool Read()
         {
-            this._customValue = false;
+            _customValue = false;
             bool read = base.Read();
 
-            if (this.NodeType == XmlNodeType.DocumentType)
-            {
-                this.ParseEntities();
-            }
+            if (NodeType == XmlNodeType.DocumentType)
+                ParseEntities();
 
             return read;
         }
 
         private void ParseEntities()
         {
             const string entityText = "<!ENTITY";
-            string[] entities = this.Value.Split(new string[] { entityText }, StringSplitOptions.None);
-            string name = null;
-            string value = null;
-            int quoteIndex;
+            var entities = Value.Split(new string[] { entityText }, StringSplitOptions.None);
 
-            foreach (string entity in entities)
+            foreach (var entity in entities)
             {
                 if (string.IsNullOrEmpty(entity.Trim()))
-                {
                     continue;
-                }
 
-                name = entity.Trim();
-                quoteIndex = name.IndexOf(this.QuoteChar);
+                var name = entity.Trim();
+                var quoteIndex = name.IndexOf(QuoteChar);
                 if (quoteIndex > 0)
                 {
-                    value = name.Substring(quoteIndex + 1, name.LastIndexOf(this.QuoteChar) - quoteIndex - 1);
+                    var value = name.Substring(quoteIndex + 1, name.LastIndexOf(QuoteChar) - quoteIndex - 1);
                     name = name.Substring(0, quoteIndex).Trim();
-                    this.Entities.Add(name, value);
+                    _entities.Add(name, value);
                 }
             }
         }
@@ -152,18 +119,18 @@ private void ParseEntities()
         /// </summary>
         public override void ResolveEntity()
         {
-            if (this.NodeType == XmlNodeType.EntityReference)
+            if (NodeType == XmlNodeType.EntityReference)
             {
-                if (this._entities.ContainsKey(this.Name))
+                if (_entities.ContainsKey(Name))
                 {
-                    this._value = this._entities[this.Name];
+                    _value = _entities[Name];
                 }
                 else
                 {
-                    this._value = string.Empty;
+                    _value = string.Empty;
                 }
 
-                this._customValue = true;
+                _customValue = true;
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public override SvgElement DeepCopy()`
`35`	`35`	`return DeepCopy<SvgDocumentMetadata>();`
`36`	`36`	`}`
`37`	`37`
`38`		`- public override void InitialiseFromXML(XmlTextReader reader, SvgDocument document)`
	`38`	`+ public override void InitialiseFromXML(XmlReader reader, SvgDocument document)`
`39`	`39`	`{`
`40`	`40`	`base.InitialiseFromXML(reader, document);`
`41`	`41`
Original file line number	Diff line number	Diff line change
`@@ -568,7 +568,7 @@ void Attributes_AttributeChanged(object sender, AttributeEventArgs e)`
`568`	`568`	`OnAttributeChanged(e);`
`569`	`569`	`}`
`570`	`570`
`571`		`- public virtual void InitialiseFromXML(XmlTextReader reader, SvgDocument document)`
	`571`	`+ public virtual void InitialiseFromXML(XmlReader reader, SvgDocument document)`
`572`	`572`	`{`
`573`	`573`	`throw new NotImplementedException();`
`574`	`574`	`}`
`@@ -963,7 +963,7 @@ private bool TryResolveParentAttributeValue(string attributeKey, out object pare`
`963`	`963`	`/// <remarks>`
`964`	`964`	`/// Recommendation is to create an XmlWriter by calling a factory method,<br/>`
`965`	`965`	`/// e.g. <see cref="XmlWriter.Create(System.IO.Stream)"/>,`
`966`		`- /// as per <a href="https://docs.microsoft.com/dotnet/api/system.xml.xmltextreader#remarks">Microsoft documentation</a>.<br/>`
	`966`	`+ /// as per <a href="https://docs.microsoft.com/dotnet/api/system.xml.xmltextwriter#remarks">Microsoft documentation</a>.<br/>`
`967`	`967`	`/// <br/>`
`968`	`968`	`/// However, unlike an <see cref="XmlTextWriter"/> created via 'new XmlTextWriter()',<br/>`
`969`	`969`	`/// a factory-constructed XmlWriter will not flush output until it is closed<br/>`
Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,13 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`		`-using System.Linq;`
`4`		`-using System.Text;`
`5`		`-using System.Xml;`
`6`	`3`	`using System.IO;`
`7`		`-using System.Collections.Specialized;`
	`4`	`+using System.Xml;`
`8`	`5`
`9`	`6`	`namespace Svg`
`10`	`7`	`{`
`11`	`8`	`internal sealed class SvgTextReader : XmlTextReader`
`12`	`9`	`{`
`13`		`- private Dictionary<string, string> _entities;`
	`10`	`+ private readonly Dictionary<string, string> _entities;`
`14`	`11`	`private string _value;`
`15`	`12`	`private bool _customValue = false;`
`16`	`13`	`private string _localName;`
`@@ -19,16 +16,16 @@ public SvgTextReader(Stream stream, Dictionary<string, string> entities)`
`19`	`16`	`: base(stream)`
`20`	`17`	`{`
`21`	`18`	`if (entities == null)`
`22`		`- this.EntityHandling = EntityHandling.ExpandEntities;`
`23`		`- this._entities = entities;`
	`19`	`+ EntityHandling = EntityHandling.ExpandEntities;`
	`20`	`+ _entities = entities ?? new Dictionary<string, string>();`
`24`	`21`	`}`
`25`	`22`
`26`	`23`	`public SvgTextReader(TextReader reader, Dictionary<string, string> entities)`
`27`	`24`	`: base(reader)`
`28`	`25`	`{`
`29`	`26`	`if (entities == null)`
`30`		`- this.EntityHandling = EntityHandling.ExpandEntities;`
`31`		`- this._entities = entities;`
	`27`	`+ EntityHandling = EntityHandling.ExpandEntities;`
	`28`	`+ _entities = entities ?? new Dictionary<string, string>();`
`32`	`29`	`}`
`33`	`30`
`34`	`31`	`/// <summary>`
`@@ -38,10 +35,7 @@ public SvgTextReader(TextReader reader, Dictionary<string, string> entities)`
`38`	`35`	/// <returns>The value returned depends on the <see cref="P:System.Xml.XmlTextReader.NodeType"/> of the node. The following table lists node types that have a value to return. All other node types return String.Empty.Node Type Value AttributeThe value of the attribute. CDATAThe content of the CDATA section. CommentThe content of the comment. DocumentTypeThe internal subset. ProcessingInstructionThe entire content, excluding the target. SignificantWhitespaceThe white space within an xml:space= 'preserve' scope. TextThe content of the text node. WhitespaceThe white space between markup. XmlDeclarationThe content of the declaration. </returns>
`39`	`36`	`public override string Value`
`40`	`37`	`{`
`41`		`- get`
`42`		`- {`
`43`		`- return (this._customValue) ? this._value : base.Value;`
`44`		`- }`
	`38`	`+ get { return _customValue ? _value : base.Value; }`
`45`	`39`	`}`
`46`	`40`
`47`	`41`	`/// <summary>`
`@@ -51,23 +45,7 @@ public override string Value`
`51`	`45`	`/// <returns>The name of the current node with the prefix removed. For example, LocalName is book for the element <bk:book>.For node types that do not have a name (like Text, Comment, and so on), this property returns String.Empty.</returns>`
`52`	`46`	`public override string LocalName`
`53`	`47`	`{`
`54`		`- get`
`55`		`- {`
`56`		`- return (this._customValue) ? this._localName : base.LocalName;`
`57`		`- }`
`58`		`- }`
`59`		`-`
`60`		`- private IDictionary<string, string> Entities`
`61`		`- {`
`62`		`- get`
`63`		`- {`
`64`		`- if (this._entities == null)`
`65`		`- {`
`66`		`- this._entities = new Dictionary<string, string>();`
`67`		`- }`
`68`		`-`
`69`		`- return this._entities;`
`70`		`- }`
	`48`	`+ get { return _customValue ? _localName : base.LocalName; }`
`71`	`49`	`}`
`72`	`50`
`73`	`51`	`/// <summary>`
`@@ -82,20 +60,16 @@ public override bool MoveToNextAttribute()`
`82`	`60`
`83`	`61`	`if (moved)`
`84`	`62`	`{`
`85`		`- this._localName = base.LocalName;`
	`63`	`+ _localName = base.LocalName;`
`86`	`64`
`87`		`- if (this.ReadAttributeValue())`
	`65`	`+ if (ReadAttributeValue())`
`88`	`66`	`{`
`89`		`- if (this.NodeType == XmlNodeType.EntityReference)`
`90`		`- {`
`91`		`- this.ResolveEntity();`
`92`		`- }`
	`67`	`+ if (NodeType == XmlNodeType.EntityReference)`
	`68`	`+ ResolveEntity();`
`93`	`69`	`else`
`94`		`- {`
`95`		`- this._value = base.Value;`
`96`		`- }`
	`70`	`+ _value = base.Value;`
`97`	`71`	`}`
`98`		`- this._customValue = true;`
	`72`	`+ _customValue = true;`
`99`	`73`	`}`
`100`	`74`
`101`	`75`	`return moved;`
`@@ -110,39 +84,32 @@ public override bool MoveToNextAttribute()`
`110`	`84`	`/// <exception cref="T:System.Xml.XmlException">An error occurred while parsing the XML. </exception>`
`111`	`85`	`public override bool Read()`
`112`	`86`	`{`
`113`		`- this._customValue = false;`
	`87`	`+ _customValue = false;`
`114`	`88`	`bool read = base.Read();`
`115`	`89`
`116`		`- if (this.NodeType == XmlNodeType.DocumentType)`
`117`		`- {`
`118`		`- this.ParseEntities();`
`119`		`- }`
	`90`	`+ if (NodeType == XmlNodeType.DocumentType)`
	`91`	`+ ParseEntities();`
`120`	`92`
`121`	`93`	`return read;`
`122`	`94`	`}`
`123`	`95`
`124`	`96`	`private void ParseEntities()`
`125`	`97`	`{`
`126`	`98`	`const string entityText = "<!ENTITY";`
`127`		`- string[] entities = this.Value.Split(new string[] { entityText }, StringSplitOptions.None);`
`128`		`- string name = null;`
`129`		`- string value = null;`
`130`		`- int quoteIndex;`
	`99`	`+ var entities = Value.Split(new string[] { entityText }, StringSplitOptions.None);`
`131`	`100`
`132`		`- foreach (string entity in entities)`
	`101`	`+ foreach (var entity in entities)`
`133`	`102`	`{`
`134`	`103`	`if (string.IsNullOrEmpty(entity.Trim()))`
`135`		`- {`
`136`	`104`	`continue;`
`137`		`- }`
`138`	`105`
`139`		`- name = entity.Trim();`
`140`		`- quoteIndex = name.IndexOf(this.QuoteChar);`
	`106`	`+ var name = entity.Trim();`
	`107`	`+ var quoteIndex = name.IndexOf(QuoteChar);`
`141`	`108`	`if (quoteIndex > 0)`
`142`	`109`	`{`
`143`		`- value = name.Substring(quoteIndex + 1, name.LastIndexOf(this.QuoteChar) - quoteIndex - 1);`
	`110`	`+ var value = name.Substring(quoteIndex + 1, name.LastIndexOf(QuoteChar) - quoteIndex - 1);`
`144`	`111`	`name = name.Substring(0, quoteIndex).Trim();`
`145`		`- this.Entities.Add(name, value);`
	`112`	`+ _entities.Add(name, value);`
`146`	`113`	`}`
`147`	`114`	`}`
`148`	`115`	`}`
`@@ -152,18 +119,18 @@ private void ParseEntities()`
`152`	`119`	`/// </summary>`
`153`	`120`	`public override void ResolveEntity()`
`154`	`121`	`{`
`155`		`- if (this.NodeType == XmlNodeType.EntityReference)`
	`122`	`+ if (NodeType == XmlNodeType.EntityReference)`
`156`	`123`	`{`
`157`		`- if (this._entities.ContainsKey(this.Name))`
	`124`	`+ if (_entities.ContainsKey(Name))`
`158`	`125`	`{`
`159`		`- this._value = this._entities[this.Name];`
	`126`	`+ _value = _entities[Name];`
`160`	`127`	`}`
`161`	`128`	`else`
`162`	`129`	`{`
`163`		`- this._value = string.Empty;`
	`130`	`+ _value = string.Empty;`
`164`	`131`	`}`
`165`	`132`
`166`		`- this._customValue = true;`
	`133`	`+ _customValue = true;`
`167`	`134`	`}`
`168`	`135`	`}`
`169`	`136`	`}`