Merge pull request #506 from LogExperts/new_reader

This pull request introduces a new set of "Memory"-based interfaces and updates the `Column` and related classes to use `ReadOnlyMemory<char>` instead of `string` for improved performance and flexibility. It also adds new helper methods for memory-based string manipulation and updates unit tests accordingly. The changes are grouped into interface additions/updates, core class refactoring, and unit test adjustments.

**Interface additions and updates:**

* Introduced new interfaces: `IColumnMemory`, `IColumnizedLogLineMemory`, `IAutoLogLineMemoryColumnizerCallback`, `IColumnizerConfiguratorMemory`, and `IColumnizerPriorityMemory` to support `ReadOnlyMemory<char>`-based operations and memory-efficient log processing. [[1]](diffhunk://#diff-eaf296844edf561a63b84b9ef2b8c924f4b8fad5be46d0a9fb1bbfbeabc5252aR1-R14) [[2]](diffhunk://#diff-e02515e0983411eb71e6aa95f8763d2e05e49580c029d5a4ec321cf2ca6cac85R1-R12) [[3]](diffhunk://#diff-e5cc913c39aac5f822d1a787dfcd6e87d7ece16c3488ef503a37e9c8a692aa0dR1-R11) [[4]](diffhunk://#diff-f76163582848504aa13c43d097cb606347dfd67fff88d79e941b7c86a2195be1R1-R33) [[5]](diffhunk://#diff-5820099353f1719a29f19a82fd07602bf7ee6c4c447716e0941d3a709a322845R1-R18)
* Updated existing interfaces and consumers to provide backward compatibility via `[Obsolete]` members and to reference new memory-based types where appropriate, such as in `IColumnizedLogLine` and `IContextMenuEntry`. [[1]](diffhunk://#diff-4e43acad58ef97a690c3d2fb084f7404e1b8966b32cdb4f3ab0f061f69881102L3-R15) [[2]](diffhunk://#diff-3ab334a54d4cee00572d2fc337cf3f7d2a32714743067dc0e31cf4c513204335L35-R37) [[3]](diffhunk://#diff-3ab334a54d4cee00572d2fc337cf3f7d2a32714743067dc0e31cf4c513204335L49-R51)

**Core class refactoring:**

* Refactored the `Column` class and related factory methods to operate on `ReadOnlyMemory<char>` instead of `string`, updated the replacement pipeline to use memory-based functions, and added private helpers for tab, truncation, and null character replacement. [[1]](diffhunk://#diff-ebd366a6ccebff87772fc1844a80b4d3d62420539e4d9d6a19d74b30a048c046L3-R5) [[2]](diffhunk://#diff-ebd366a6ccebff87772fc1844a80b4d3d62420539e4d9d6a19d74b30a048c046L13-R20) [[3]](diffhunk://#diff-ebd366a6ccebff87772fc1844a80b4d3d62420539e4d9d6a19d74b30a048c046L29-R86) [[4]](diffhunk://#diff-ebd366a6ccebff87772fc1844a80b4d3d62420539e4d9d6a19d74b30a048c046L74-R97) [[5]](diffhunk://#diff-ebd366a6ccebff87772fc1844a80b4d3d62420539e4d9d6a19d74b30a048c046L102-R128) [[6]](diffhunk://#diff-ebd366a6ccebff87772fc1844a80b4d3d62420539e4d9d6a19d74b30a048c046L121-R230)
* Updated `ColumnizedLogLine` to implement the new memory-based interface and expose both old and new properties for compatibility.

**Unit test adjustments:**

* Updated unit tests in `ColumnTests.cs` to use `AsMemory()` for test values and to call `.ToString()` when checking `DisplayValue` for string assertions. Also added suppression attributes for globalization warnings in tests. [[1]](diffhunk://#diff-0360b593d6854dd1529b1803a960513e97d09daed09033e70748b6dfc35aa4a5L47-R47) [[2]](diffhunk://#diff-0360b593d6854dd1529b1803a960513e97d09daed09033e70748b6dfc35aa4a5L60-R61) [[3]](diffhunk://#diff-0360b593d6854dd1529b1803a960513e97d09daed09033e70748b6dfc35aa4a5L72-R72) [[4]](diffhunk://#diff-0360b593d6854dd1529b1803a960513e97d09daed09033e70748b6dfc35aa4a5R83-R88) [[5]](diffhunk://#diff-0360b593d6854dd1529b1803a960513e97d09daed09033e70748b6dfc35aa4a5R107-R112)

**General codebase cleanup:**

* Removed unused `using` statements from several interface files for clarity and maintainability. [[1]](diffhunk://#diff-14fa0b69b47a0ea7de5d351a09d989c6f1725c7c23145f269a73b70a40312513L1-L5) [[2]](diffhunk://#diff-18d4b090367c70b89766d89c953aedf0dce8eb04edc10724a6d4b2c2f1fc384dL1-L5) [[3]](diffhunk://#diff-bf531b4bca29ffb50a7baa5fa171d4dc636eb26edc1a013f2ba089e826cf2e15L1-L4)
* Added or improved XML documentation comments on interfaces for better code documentation. [[1]](diffhunk://#diff-9bbe6cc05b779d408640f0ef6cd92063a47c2967f35614249f8a2ca92730f0c8L1-R8) [[2]](diffhunk://#diff-5820099353f1719a29f19a82fd07602bf7ee6c4c447716e0941d3a709a322845R1-R18)

These changes collectively modernize the columnizer infrastructure to be more memory-efficient and extensible, paving the way for future performance improvements and better support for large log files.

Author: Hirogen

src/ColumnizerLib.UnitTests/ColumnTests.cs

@@ -44,7 +44,7 @@ public void Column_TruncatesAtConfiguredDisplayLength ()
         Column.SetMaxDisplayLength(10_000);
 
         // Create a line longer than the display max length
-        var longValue = new StringBuilder().Append('X', 15_000).ToString();
+        var longValue = new StringBuilder().Append('X', 15_000).ToString().AsMemory();
 
         Column column = new()
         {
@@ -57,8 +57,8 @@ public void Column_TruncatesAtConfiguredDisplayLength ()
 
         // DisplayValue should be truncated at 10,000 with "..." appended
         Assert.That(column.DisplayValue.Length, Is.EqualTo(10_003)); // 10000 + "..."
-        Assert.That(column.DisplayValue.EndsWith("...", StringComparison.OrdinalIgnoreCase), Is.True);
-        Assert.That(column.DisplayValue.StartsWith("XXX", StringComparison.OrdinalIgnoreCase), Is.True);
+        Assert.That(column.DisplayValue.ToString().EndsWith("...", StringComparison.OrdinalIgnoreCase), Is.True);
+        Assert.That(column.DisplayValue.ToString().StartsWith("XXX", StringComparison.OrdinalIgnoreCase), Is.True);
 
         // Reset for other tests
         Column.SetMaxDisplayLength(20_000);
@@ -69,7 +69,7 @@ public void Column_NoTruncationWhenBelowLimit ()
     {
         Column.SetMaxDisplayLength(20_000);
 
-        var normalValue = new StringBuilder().Append('Y', 5_000).ToString();
+        var normalValue = new StringBuilder().Append('Y', 5_000).ToString().AsMemory();
         Column column = new()
         {
             FullValue = normalValue
@@ -80,37 +80,28 @@ public void Column_NoTruncationWhenBelowLimit ()
     }
 
     [Test]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1303:Do not pass literals as localized parameters", Justification = "Unit Test")]
     public void Column_NullCharReplacement ()
     {
         Column column = new()
         {
-            FullValue = "asdf\0"
+            FullValue = "asdf\0".AsMemory()
         };
 
-        //Switch between the different implementation for the windows versions
-        //Not that great solution but currently I'm out of ideas, I know that currently
-        //only one implementation depending on the windows version is executed
-        if (Environment.Version >= Version.Parse("6.2"))
-        {
-            Assert.That(column.DisplayValue, Is.EqualTo("asdf␀"));
-        }
-        else
-        {
-            Assert.That(column.DisplayValue, Is.EqualTo("asdf "));
-        }
-
-        Assert.That(column.FullValue, Is.EqualTo("asdf\0"));
+        Assert.That(column.DisplayValue.ToString(), Is.EqualTo("asdf "));
+        Assert.That(column.FullValue.ToString(), Is.EqualTo("asdf\0"));
     }
 
     [Test]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1303:Do not pass literals as localized parameters", Justification = "Unit Test")]
     public void Column_TabReplacement ()
     {
         Column column = new()
         {
-            FullValue = "asdf\t"
+            FullValue = "asdf\t".AsMemory()
         };
 
-        Assert.That(column.DisplayValue, Is.EqualTo("asdf  "));
-        Assert.That(column.FullValue, Is.EqualTo("asdf\t"));
+        Assert.That(column.DisplayValue.ToString(), Is.EqualTo("asdf  "));
+        Assert.That(column.FullValue.ToString(), Is.EqualTo("asdf\t"));
     }
 }

src/ColumnizerLib/Column.cs

@@ -1,7 +1,8 @@
 namespace ColumnizerLib;
 
-public class Column : IColumn
+public class Column : IColumnMemory
 {
+    //TODO Memory Functions need implementation
     #region Fields
 
     private const string REPLACEMENT = "...";
@@ -10,14 +11,14 @@ public class Column : IColumn
     // Can be configured via SetMaxDisplayLength()
     private static int _maxDisplayLength = 20_000;
 
-    private static readonly List<Func<string, string>> _replacements = [
+    private static readonly List<Func<ReadOnlyMemory<char>, ReadOnlyMemory<char>>> _replacementsMemory = [
         //replace tab with 3 spaces, from old coding. Needed???
-                input => input.Replace("\t", "  ", StringComparison.Ordinal),
+        ReplaceTab,
 
-                //shorten string if it exceeds maxLength
-                input => input.Length > _maxDisplayLength
-                        ? string.Concat(input.AsSpan(0, _maxDisplayLength), REPLACEMENT)
-                        : input
+        //shorten string if it exceeds maxLength
+        input => input.Length > _maxDisplayLength
+                ? ShortenMemory(input, _maxDisplayLength)
+                : input
     ];
 
     #endregion
@@ -26,43 +27,63 @@ public class Column : IColumn
 
     static Column ()
     {
-        if (Environment.Version >= Version.Parse("6.2"))
-        {
-            //Win8 or newer support full UTF8 chars with the preinstalled fonts.
-            //Replace null char with UTF8 Symbol U+2400 (␀)
-            _replacements.Add(input => input.Replace("\0", "␀", StringComparison.Ordinal));
-        }
-        else
-        {
-            //Everything below Win8 the installed fonts seems to not to support reliabel
-            //Replace null char with space
-            //.net 10 does no longer support windows lower then windows 10
-            //TODO: remove if with one of the next releases
-            //https://github.com/dotnet/core/blob/main/release-notes/10.0/supported-os.md
-            _replacements.Add(input => input.Replace("\0", " ", StringComparison.Ordinal));
-        }
+        //.net 10 only supports Windows10+ which has full UTF8-font support
+        // Replace null char with UTF-8 Symbol U+2400 (␀)
+        //https://github.com/dotnet/core/blob/main/release-notes/10.0/supported-os.md
+        _replacementsMemory.Add(input => ReplaceNullChar(input, ' '));
 
-        EmptyColumn = new Column { FullValue = string.Empty };
+        EmptyColumn = new Column { FullValue = ReadOnlyMemory<char>.Empty };
     }
 
     #endregion
 
     #region Properties
 
-    public static IColumn EmptyColumn { get; }
+    public static IColumnMemory EmptyColumn { get; }
+
+    [Obsolete]
+    IColumnizedLogLine IColumn.Parent { get; }
+
+    [Obsolete]
+    string IColumn.FullValue
+    {
+        get;
+        //set
+        //{
+        //    field = value;
+
+        //    var temp = FullValue.ToString();
+
+        //    foreach (var replacement in _replacements)
+        //    {
+        //        temp = replacement(temp);
+        //    }
+
+        //    DisplayValue = temp.AsMemory();
+        //}
+    }
+
+    [Obsolete("Use the DisplayValue property of IColumnMemory")]
+    string IColumn.DisplayValue { get; }
+
+    [Obsolete("Use Text property of ITextValueMemory")]
+    string ITextValue.Text => DisplayValue.ToString();
 
-    public IColumnizedLogLine Parent { get; set; }
+    public IColumnizedLogLineMemory Parent
+    {
+        get; set => field = value;
+    }
 
-    public string FullValue
+    public ReadOnlyMemory<char> FullValue
     {
         get;
         set
         {
             field = value;
 
-            var temp = FullValue;
+            var temp = value;
 
-            foreach (var replacement in _replacements)
+            foreach (var replacement in _replacementsMemory)
             {
                 temp = replacement(temp);
             }
@@ -71,9 +92,9 @@ public string FullValue
         }
     }
 
-    public string DisplayValue { get; private set; }
+    public ReadOnlyMemory<char> DisplayValue { get; private set; }
 
-    public string Text => DisplayValue;
+    public ReadOnlyMemory<char> Text => DisplayValue;
 
     #endregion
 
@@ -99,12 +120,12 @@ public static void SetMaxDisplayLength (int maxLength)
     /// </summary>
     public static int GetMaxDisplayLength () => _maxDisplayLength;
 
-    public static Column[] CreateColumns (int count, IColumnizedLogLine parent)
+    public static Column[] CreateColumns (int count, IColumnizedLogLineMemory parent)
     {
-        return CreateColumns(count, parent, string.Empty);
+        return CreateColumns(count, parent, ReadOnlyMemory<char>.Empty);
     }
 
-    public static Column[] CreateColumns (int count, IColumnizedLogLine parent, string defaultValue)
+    public static Column[] CreateColumns (int count, IColumnizedLogLineMemory parent, ReadOnlyMemory<char> defaultValue)
     {
         var output = new Column[count];
 
@@ -118,7 +139,95 @@ public static Column[] CreateColumns (int count, IColumnizedLogLine parent, stri
 
     public override string ToString ()
     {
-        return DisplayValue ?? string.Empty;
+        return DisplayValue.ToString() ?? ReadOnlyMemory<char>.Empty.ToString();
+    }
+
+    #endregion
+
+    #region Private Methods
+
+    /// <summary>
+    /// Replaces tab characters with two spaces in the memory buffer.
+    /// </summary>
+    private static ReadOnlyMemory<char> ReplaceTab (ReadOnlyMemory<char> input)
+    {
+        var span = input.Span;
+        var tabIndex = span.IndexOf('\t');
+
+        if (tabIndex == -1)
+        {
+            return input;
+        }
+
+        // Count total tabs to calculate new length
+        var tabCount = 0;
+        foreach (var c in span)
+        {
+            if (c == '\t')
+            {
+                tabCount++;
+            }
+        }
+
+        // Allocate new buffer: original length + (tabCount * 1) since we replace 1 char with 2
+        var newLength = input.Length + tabCount;
+        var buffer = new char[newLength];
+        var bufferPos = 0;
+
+        for (var i = 0; i < span.Length; i++)
+        {
+            if (span[i] == '\t')
+            {
+                buffer[bufferPos++] = ' ';
+                buffer[bufferPos++] = ' ';
+            }
+            else
+            {
+                buffer[bufferPos++] = span[i];
+            }
+        }
+
+        return buffer;
+    }
+
+    /// <summary>
+    /// Shortens the memory buffer to the specified maximum length and appends "...".
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1303:Do not pass literals as localized parameters", Justification = "Non Localiced Parameter")]
+    private static ReadOnlyMemory<char> ShortenMemory (ReadOnlyMemory<char> input, int maxLength)
+    {
+        var buffer = new char[maxLength + REPLACEMENT.Length];
+        input.Span[..maxLength].CopyTo(buffer);
+        REPLACEMENT.AsSpan().CopyTo(buffer.AsSpan(maxLength));
+        return buffer;
+    }
+
+    /// <summary>
+    /// Replaces null characters with the specified replacement character.
+    /// </summary>
+    private static ReadOnlyMemory<char> ReplaceNullChar (ReadOnlyMemory<char> input, char replacement)
+    {
+        var span = input.Span;
+        var nullIndex = span.IndexOf('\0');
+
+        if (nullIndex == -1)
+        {
+            return input;
+        }
+
+        // Need to create a new buffer since we're modifying content
+        var buffer = new char[input.Length];
+        span.CopyTo(buffer);
+
+        for (var i = 0; i < buffer.Length; i++)
+        {
+            if (buffer[i] == '\0')
+            {
+                buffer[i] = replacement;
+            }
+        }
+
+        return buffer;
     }
 
     #endregion

src/ColumnizerLib/ColumnizedLogLine.cs

@@ -1,12 +1,18 @@
 namespace ColumnizerLib;
 
-public class ColumnizedLogLine : IColumnizedLogLine
+public class ColumnizedLogLine : IColumnizedLogLineMemory
 {
     #region Properties
 
-    public ILogLine LogLine { get; set; }
+    [Obsolete("Use the Property of IColumnizedLogLineMemory")]
+    ILogLine IColumnizedLogLine.LogLine { get; }
 
-    public IColumn[] ColumnValues { get; set; }
+    [Obsolete("Use the Property of IColumnizedLogLineMemory")]
+    IColumn[] IColumnizedLogLine.ColumnValues { get; }
+
+    public ILogLineMemory LogLine { get; set; }
+
+    public IColumnMemory[] ColumnValues { get; set; }
 
     #endregion
 }

src/ColumnizerLib/IAutoLogLineMemoryColumnizerCallback.cs

@@ -0,0 +1,11 @@
+namespace ColumnizerLib;
+
+public interface IAutoLogLineMemoryColumnizerCallback : IAutoLogLineColumnizerCallback
+{
+    /// <summary>
+    /// Returns the log line with the given index (zero-based).
+    /// </summary>
+    /// <param name="lineNum">Number of the line to be retrieved</param>
+    /// <returns>A string with line content or null if line number is out of range</returns>
+    ILogLineMemory GetLogLineMemory (int lineNum);
+}

src/ColumnizerLib/IColumn.cs

@@ -1,8 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
 namespace ColumnizerLib;
 
 public interface IColumn : ITextValue

src/ColumnizerLib/IColumnMemory.cs

@@ -0,0 +1,14 @@
+namespace ColumnizerLib;
+
+public interface IColumnMemory : IColumn, ITextValueMemory
+{
+    #region Properties
+
+    new IColumnizedLogLineMemory Parent { get; }
+
+    new ReadOnlyMemory<char> FullValue { get; }
+
+    new ReadOnlyMemory<char> DisplayValue { get; }
+
+    #endregion
+}

src/ColumnizerLib/IColumnizedLogLine.cs

@@ -1,8 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
 namespace ColumnizerLib;
 
 public interface IColumnizedLogLine
@@ -11,7 +6,6 @@ public interface IColumnizedLogLine
 
     ILogLine LogLine { get; }
 
-
     IColumn[] ColumnValues { get; }
 
     #endregion