Ported libs fo net V6

HaXMLReaderV6/EvArgs/Tag.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using HaXMLReader.Interfaces;
+namespace HaXMLReader.EvArgs
+{
+    public class Tag : EventArgs, IReaderEvArg
+    {
+        public string Name { get; set; } = "";
+        public Dictionary<string, string> Values { get; set; } = new Dictionary<string, string>();
+        public bool IsEmpty { get; set; } = false;
+        public bool EndTag { get; set; } = false;
+
+        // Privides safe access to the values Dict
+        public string this[string key]
+        {
+            get
+            {
+                if (Values != null && Values.ContainsKey(key))
+                    return Values[key];
+                else
+                    return "";
+            }
+        }
+    }
+}

HaXMLReaderV6/EvArgs/Text.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using HaXMLReader.Interfaces;
+
+namespace HaXMLReader.EvArgs
+{
+    public class Text : EventArgs, IReaderEvArg
+    {
+        public string Value { get; set; } = "";
+    }
+}

HaXMLReaderV6/EvArgs/Whitespace.cs

@@ -0,0 +1,8 @@
+using HaXMLReader.Interfaces;
+
+namespace HaXMLReader.EvArgs {
+    public class Whitespace : System.EventArgs, IReaderEvArg {
+        public string Value { get; set; }
+
+    }
+}

HaXMLReaderV6/FileReader.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Xml;
+using System.Collections;
+using System.Collections.Generic;
+using HaXMLReader.EvArgs;
+using HaXMLReader.Interfaces;
+
+namespace HaXMLReader
+{
+    public class FileReader : Reader, IReader
+    {
+        private readonly string _uri;
+        private MemoryStream _memoryStream;
+
+        public FileReader(string uri)
+        {
+            _uri = uri;
+            _memoryStream = new MemoryStream(File.ReadAllBytes(_uri));
+            CreateReader();
+        }
+
+        public FileReader(string uri, Action<string[]> Logsink) : this(uri)
+        {
+            _LogSink = Logsink;
+        }
+
+        public override void Dispose()
+        {
+            base.Dispose();
+            _memoryStream.Dispose();
+        }
+
+        protected override XmlReader GetReader() {
+            return XmlReader.Create(_memoryStream, _Settings);
+        }
+    }
+}

HaXMLReaderV6/HaXMLReaderV6.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

HaXMLReaderV6/Interfaces/IReader.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Xml;
+using HaXMLReader.EvArgs;
+
+namespace HaXMLReader.Interfaces {
+    public interface IReader {
+        event EventHandler ReadingStart;
+        event EventHandler ReadingStop;
+
+        event EventHandler<Tag> Tag;
+        event EventHandler<Tag> OpenTag;
+        event EventHandler<Tag> CloseTag;
+        event EventHandler<Tag> SingleTag;
+        event EventHandler<Whitespace> Whitespace;
+        event EventHandler<Text> Text;
+
+        void Log(params string[] message);
+        void Read();
+
+        void Dispose();
+        void ImportSettings(XmlReaderSettings settings);
+        IReader CreateReaderForSubtree(Func<Tag, bool> Condition);
+        IReader CreateReaderForSubtree(string elementname);
+
+        // Legacy
+        void Close();
+    }
+}

HaXMLReaderV6/Interfaces/IReaderArg.cs

@@ -0,0 +1,7 @@
+using System;
+
+namespace HaXMLReader.Interfaces {
+    public interface IReaderEvArg {
+
+    }
+}

HaXMLReaderV6/Interfaces/IReaderService.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Xml.Linq;
+
+namespace HaXMLReader.Interfaces {
+    /// <summary>
+    /// Is a simple service to create appropriate IReader Instances.
+    /// </summary>
+    public interface IReaderService {
+        IReader RequestReader(XElement element);
+        IReader RequestReader(XElement element, Action<string[]> logsink);
+
+        IReader RequestReader(string uri);
+        IReader RequestReader(string uri, Action<string[]> logsink);
+
+        IReader RequestStringReader(string toread);
+    }
+}

HaXMLReaderV6/Reader.cs

@@ -0,0 +1,174 @@
+using System;
+using HaXMLReader.EvArgs;
+using System.Linq;
+using System.IO;
+using System.Xml;
+using System.Collections;
+using System.ComponentModel;
+using System.Collections.Generic;
+using HaXMLReader.Interfaces;
+
+namespace HaXMLReader
+{
+    public abstract class Reader : IReader
+    {
+        public event EventHandler ReadingStart;
+        public event EventHandler ReadingStop;
+        public event EventHandler<Tag> Tag;
+        public event EventHandler<Tag> OpenTag;
+        public event EventHandler<Tag> CloseTag;
+        public event EventHandler<Tag> SingleTag;
+        public event EventHandler<Whitespace> Whitespace;
+        public event EventHandler<Text> Text;
+
+        protected Action<string[]> _LogSink { get; set; }
+        private XmlReader _XReader { get; set; } = null;
+
+        //State:
+        internal XmlReaderSettings _Settings = new XmlReaderSettings()
+        {
+            CloseInput = true,
+            CheckCharacters = false,
+            ConformanceLevel = ConformanceLevel.Fragment,
+            IgnoreComments = true,
+            IgnoreProcessingInstructions = true,
+            IgnoreWhitespace = false
+        };
+
+        public void Log(params string[] message)
+        {
+            if (_LogSink != null) _LogSink.Invoke(message.Select(x => x = "HamannDocument: \t" + x).ToArray());
+        }
+
+        public void Read()
+        {
+            if (_XReader == null || 
+                _XReader.ReadState == ReadState.Closed || 
+                _XReader.ReadState == ReadState.EndOfFile ||
+                _XReader.ReadState == ReadState.Error) {
+                    CreateReader();
+            }
+            ReadingStart?.Invoke(this, EventArgs.Empty);
+            while (_XReader.Read())
+            {
+                _Read();
+            }
+            ReadingStop?.Invoke(this, EventArgs.Empty);
+            Dispose();
+        }
+
+        private void _Read() {
+            try {
+                switch (_XReader.NodeType)
+                {
+                    case XmlNodeType.Text:
+                        Text?.Invoke(this, new Text() { Value = _XReader.Value });
+                        break;
+                    case XmlNodeType.SignificantWhitespace:
+                        Whitespace?.Invoke(this, new Whitespace() { Value = _XReader.Value });
+                        break;
+                    case XmlNodeType.Whitespace:
+                        Whitespace?.Invoke(this, new Whitespace() { Value = _XReader.Value });
+                        break;
+                    case XmlNodeType.Element:
+                        var tag = _TagCreation();
+                        Tag?.Invoke(this, tag);
+                        if (tag.IsEmpty) SingleTag?.Invoke(this, tag);
+                        else OpenTag?.Invoke(this, tag);
+                        break;
+                    case XmlNodeType.EndElement:
+                        var tg = _TagCreation();
+                        Tag?.Invoke(this, tg);
+                        CloseTag?.Invoke(this, tg);
+                        break;
+                }
+            }
+            catch (XmlException ex) {
+                Log(ex.Message);
+                throw ex;
+            }
+        }
+
+        public IReader CreateReaderForSubtree(string elementname) {
+            if (_XReader == null) CreateReader();
+            else throw new InvalidOperationException("Der Status des Readers kann nicht verändert werden.");
+            _skipUntilElement(elementname);
+            return _createReaderForSubtree();
+        }
+
+        public IReader CreateReaderForSubtree(Func<Tag, bool> Condition) {
+            if (_XReader == null) CreateReader();
+            else throw new InvalidOperationException("Der Status des Readers kann nicht verändert werden.");
+            while (_XReader.Read()) {
+                if(_XReader.NodeType == XmlNodeType.Element) {
+                    var tag = _TagCreation();
+                    if (Condition(tag))
+                        return _createReaderForSubtree();
+                }
+            }
+            return null;
+        }
+
+        private IReader _createReaderForSubtree() {
+            if (_XReader.NodeType == XmlNodeType.Attribute)
+                _XReader.MoveToElement();
+            return new XmlReaderReader(_XReader.ReadSubtree());
+        }
+
+        public void ImportSettings(XmlReaderSettings settings) {
+            _Settings = settings;
+        }
+
+        public virtual void Dispose() {
+        }
+
+        // Legacy:
+        public void Close() {
+            _XReader.Close();
+        }
+
+        protected void CreateReader() {
+            if (_XReader == null || 
+                _XReader.ReadState == ReadState.Closed || 
+                _XReader.ReadState == ReadState.EndOfFile ||
+                _XReader.ReadState == ReadState.Error) {
+                _XReader = GetReader();
+            }
+        }
+        
+        protected abstract XmlReader GetReader();
+
+        private void _skipUntilElement(string name) {
+            if (_XReader == null) CreateReader();
+            else throw new InvalidOperationException("Der Status des Readers kann nicht verändert werden.");
+            _XReader.ReadToFollowing(name);
+        }
+
+        private Tag _TagCreation() {
+            var tag = new Tag();
+            tag.Name = _XReader.Name;
+            tag.IsEmpty = _XReader.IsEmptyElement;
+            tag.EndTag = _XReader.NodeType == XmlNodeType.EndElement ? true : false;
+            if (_XReader.HasAttributes)
+            {                
+                int no = _XReader.AttributeCount;
+                for (int step = 0; step < no; step++)
+                {
+                    _XReader.MoveToAttribute(step);
+                    tag.Values.Add(_XReader.Name.ToLower(), _XReader.Value);
+                }
+            }
+            return tag;
+        }
+
+        private void _checkReadStateInteractive() {
+            if (_XReader != null && _XReader.ReadState != ReadState.Interactive) {
+                Dispose();
+                var ex = new InvalidOperationException("The Reader is currently not in a reading state");
+                Log(ex.Message);
+                throw ex;
+            }
+            return;
+        }
+    }
+}

HaXMLReaderV6/ReaderService.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Xml.Linq;
+using HaXMLReader.Interfaces;
+
+namespace HaXMLReader {
+    /// <summary>
+    /// Very basic IReader-Factory. Lifetime of a reader must be handled outside.
+    /// Allows using any Reader as a service e.g. within web projects.
+    /// Allow injecting the service into another project.
+    /// </summary>
+    public class ReaderService : IReaderService {
+        public IReader RequestReader(XElement element) => new XElementReader(element);
+        public IReader RequestReader(XElement element, Action<string[]> logsink) => new XElementReader(element, logsink);
+        public IReader RequestReader(string uri) => new FileReader(uri);
+        public IReader RequestReader(string uri, Action<string[]> logsink) => new FileReader(uri, logsink);
+        public IReader RequestStringReader(String toread) => new UTF8StringReader(toread);
+    }
+}

HaXMLReaderV6/UTF8StringReader.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Text;
+using System.IO;
+using System.Xml;
+using HaXMLReader.Interfaces;
+
+namespace HaXMLReader {
+    public class UTF8StringReader : Reader, IReader {
+        private readonly string _str;
+        private StringReader _memoryStream;
+
+        public UTF8StringReader(string str)
+        {
+            _str = str;
+            _memoryStream = new StringReader(str);
+            CreateReader();
+        }
+
+        public UTF8StringReader(string str, Action<string[]> Logsink) : this(str)
+        {
+            _LogSink = Logsink;
+        }
+
+        public override void Dispose()
+        {
+            base.Dispose();
+            _memoryStream.Dispose();
+        }
+
+        protected override XmlReader GetReader() {
+            return XmlReader.Create(_memoryStream, _Settings);
+        }
+    }
+}

HaXMLReaderV6/XElementReader.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Xml;
+using System.Collections;
+using System.Collections.Generic;
+using HaXMLReader.Interfaces;
+using System.Xml.Linq;
+
+namespace HaXMLReader
+{
+    public class XElementReader : Reader, IReader
+    {
+        private readonly XElement _element;
+
+        public XElementReader(XElement element)
+        {
+            _element = element;
+            CreateReader();
+        }
+
+        public XElementReader(XElement element, Action<string[]> Logsink) : this(element)
+        {
+            _LogSink = Logsink;
+        }
+
+        public override void Dispose()
+        { 
+            base.Dispose();
+        }
+
+        protected override XmlReader GetReader() {
+            return _element.CreateReader();
+        }
+        
+    }
+}

HaXMLReaderV6/XmlReaderReader.cs

@@ -0,0 +1,16 @@
+using System.Xml;
+using HaXMLReader.Interfaces;
+
+namespace HaXMLReader {
+    public class XmlReaderReader : Reader, IReader {
+        private XmlReader _initial;
+
+        public XmlReaderReader(XmlReader reader) {
+            _initial = reader;
+        }
+
+        protected override XmlReader GetReader() {
+            return _initial;
+        }
+    }
+}