update nuget package, cleanup classes

src/JsonCompactColumnizer/JsonCompactColumnizer.csproj

@@ -76,7 +76,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json">
-      <Version>12.0.2</Version>
+      <Version>13.0.1</Version>
     </PackageReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

src/LogExpert/Classes/Bookmark/BookmarkDataProvider.cs

@@ -1,10 +1,8 @@
 using System;
 using System.Collections.Generic;
-using System.Reflection;
-using System.Text;
 using NLog;
 
-namespace LogExpert
+namespace LogExpert.Classes.Bookmark
 {
     internal class BookmarkDataProvider : IBookmarkData
     {
@@ -18,12 +16,12 @@ internal class BookmarkDataProvider : IBookmarkData
 
         internal BookmarkDataProvider()
         {
-            BookmarkList = new SortedList<int, Bookmark>();
+            BookmarkList = new SortedList<int, LogExpert.Bookmark>();
         }
 
-        internal BookmarkDataProvider(SortedList<int, Bookmark> bookmarkList)
+        internal BookmarkDataProvider(SortedList<int, LogExpert.Bookmark> bookmarkList)
         {
-            this.BookmarkList = bookmarkList;
+            BookmarkList = bookmarkList;
         }
 
         #endregion
@@ -47,13 +45,10 @@ internal BookmarkDataProvider(SortedList<int, Bookmark> bookmarkList)
         #endregion
 
         #region Properties
+
+        public BookmarkCollection Bookmarks => new BookmarkCollection(BookmarkList);
 
-        public BookmarkCollection Bookmarks
-        {
-            get { return new BookmarkCollection(this.BookmarkList); }
-        }
-
-        internal SortedList<int, Bookmark> BookmarkList { get; set; }
+        internal SortedList<int, LogExpert.Bookmark> BookmarkList { get; set; }
 
         #endregion
 
@@ -67,23 +62,23 @@ public void ToggleBookmark(int lineNum)
             }
             else
             {
-                AddBookmark(new Bookmark(lineNum));
+                AddBookmark(new LogExpert.Bookmark(lineNum));
             }
         }
 
         public bool IsBookmarkAtLine(int lineNum)
         {
-            return this.BookmarkList.ContainsKey(lineNum);
+            return BookmarkList.ContainsKey(lineNum);
         }
 
         public int GetBookmarkIndexForLine(int lineNum)
         {
-            return this.BookmarkList.IndexOfKey(lineNum);
+            return BookmarkList.IndexOfKey(lineNum);
         }
 
-        public Bookmark GetBookmarkForLine(int lineNum)
+        public LogExpert.Bookmark GetBookmarkForLine(int lineNum)
         {
-            return this.BookmarkList[lineNum];
+            return BookmarkList[lineNum];
         }
 
         #endregion
@@ -92,8 +87,8 @@ public Bookmark GetBookmarkForLine(int lineNum)
 
         internal void ShiftBookmarks(int offset)
         {
-            SortedList<int, Bookmark> newBookmarkList = new SortedList<int, Bookmark>();
-            foreach (Bookmark bookmark in this.BookmarkList.Values)
+            SortedList<int, LogExpert.Bookmark> newBookmarkList = new SortedList<int, LogExpert.Bookmark>();
+            foreach (LogExpert.Bookmark bookmark in BookmarkList.Values)
             {
                 int line = bookmark.LineNum - offset;
                 if (line >= 0)
@@ -102,26 +97,26 @@ internal void ShiftBookmarks(int offset)
                     newBookmarkList.Add(line, bookmark);
                 }
             }
-            this.BookmarkList = newBookmarkList;
+            BookmarkList = newBookmarkList;
         }
 
         internal int FindPrevBookmarkIndex(int lineNum)
         {
-            IList<Bookmark> values = this.BookmarkList.Values;
-            for (int i = this.BookmarkList.Count - 1; i >= 0; --i)
+            IList<LogExpert.Bookmark> values = BookmarkList.Values;
+            for (int i = BookmarkList.Count - 1; i >= 0; --i)
             {
                 if (values[i].LineNum <= lineNum)
                 {
                     return i;
                 }
             }
-            return this.BookmarkList.Count - 1;
+            return BookmarkList.Count - 1;
         }
 
         internal int FindNextBookmarkIndex(int lineNum)
         {
-            IList<Bookmark> values = this.BookmarkList.Values;
-            for (int i = 0; i < this.BookmarkList.Count; ++i)
+            IList<LogExpert.Bookmark> values = BookmarkList.Values;
+            for (int i = 0; i < BookmarkList.Count; ++i)
             {
                 if (values[i].LineNum >= lineNum)
                 {
@@ -133,57 +128,48 @@ internal int FindNextBookmarkIndex(int lineNum)
 
         internal void RemoveBookmarkForLine(int lineNum)
         {
-            this.BookmarkList.Remove(lineNum);
+            BookmarkList.Remove(lineNum);
             OnBookmarkRemoved();
         }
 
         internal void RemoveBookmarksForLines(List<int> lineNumList)
         {
             foreach (int lineNum in lineNumList)
             {
-                this.BookmarkList.Remove(lineNum);
+                BookmarkList.Remove(lineNum);
             }
             OnBookmarkRemoved();
         }
 
 
-        internal void AddBookmark(Bookmark bookmark)
+        internal void AddBookmark(LogExpert.Bookmark bookmark)
         {
-            this.BookmarkList.Add(bookmark.LineNum, bookmark);
+            BookmarkList.Add(bookmark.LineNum, bookmark);
             OnBookmarkAdded();
         }
 
         internal void ClearAllBookmarks()
         {
             _logger.Debug("Removing all bookmarks");
-            this.BookmarkList.Clear();
+            BookmarkList.Clear();
             OnAllBookmarksRemoved();
         }
 
         #endregion
 
         protected void OnBookmarkAdded()
         {
-            if (BookmarkAdded != null)
-            {
-                BookmarkAdded(this, new EventArgs());
-            }
+            BookmarkAdded?.Invoke(this, EventArgs.Empty);
         }
 
         protected void OnBookmarkRemoved()
         {
-            if (BookmarkRemoved != null)
-            {
-                BookmarkRemoved(this, new EventArgs());
-            }
+            BookmarkRemoved?.Invoke(this, EventArgs.Empty);
         }
 
         protected void OnAllBookmarksRemoved()
         {
-            if (AllBookmarksRemoved != null)
-            {
-                AllBookmarksRemoved(this, new EventArgs());
-            }
+            AllBookmarksRemoved?.Invoke(this, EventArgs.Empty);
         }
     }
 }

src/LogExpert/Classes/Log/LogStreamReaderBase.cs

@@ -1,8 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace LogExpert.Classes.Log
 {

src/LogExpert/Classes/Log/LogfileReader.cs

@@ -990,8 +990,7 @@ private void ReadToBufferList(ILogFileInfo logFileInfo, long filePos, int startL
                             int droppedLines = logBuffer.PrevBuffersDroppedLinesSum;
                             filePos = reader.Position;
 
-                            while (ReadLine(reader, logBuffer.StartLine + logBuffer.LineCount,
-                                logBuffer.StartLine + logBuffer.LineCount + droppedLines, out var line))
+                            while (ReadLine(reader, logBuffer.StartLine + logBuffer.LineCount, logBuffer.StartLine + logBuffer.LineCount + droppedLines, out var line))
                             {
                                 LogLine logLine = new LogLine();
                                 if (_shouldStop)
@@ -1645,6 +1644,7 @@ private ILogStreamReader GetLogStreamReader(Stream stream, EncodingOptions encod
 
             return IsXmlMode ? new XmlBlockSplitter(new XmlLogReader(reader), XmlLogConfig) : reader;
         }
+
         private ILogStreamReader CreateLogStreamReader(Stream stream, EncodingOptions encodingOptions, bool useSystemReader)
         {
             if (useSystemReader)

src/LogExpert/Classes/Log/PositionAwareStreamReaderBase.cs

@@ -8,9 +8,9 @@ public abstract class PositionAwareStreamReaderBase : LogStreamReaderBase
     {
         #region Fields
 
-        protected const int MAX_LINE_LEN = 20000;
+        private const int MAX_LINE_LEN = 20000;
 
-        private static readonly Encoding[] _preambleEncodings = new Encoding[] { Encoding.UTF8, Encoding.Unicode, Encoding.BigEndianUnicode, Encoding.UTF32 };
+        private static readonly Encoding[] _preambleEncodings = { Encoding.UTF8, Encoding.Unicode, Encoding.BigEndianUnicode, Encoding.UTF32 };
 
         private readonly BufferedStream _stream;
         private readonly StreamReader _reader;
@@ -30,8 +30,8 @@ protected PositionAwareStreamReaderBase(Stream stream, EncodingOptions encodingO
 
             _preambleLength = DetectPreambleLengthAndEncoding(out Encoding detectedEncoding);
 
-            Encoding usedEncoding = getUsedEncoding(encodingOptions, detectedEncoding);
-            _posIncPrecomputed = getPosIncPrecomputed(usedEncoding);
+            Encoding usedEncoding = GetUsedEncoding(encodingOptions, detectedEncoding);
+            _posIncPrecomputed = GetPosIncPrecomputed(usedEncoding);
 
             _reader = new StreamReader(_stream, usedEncoding, true);
 
@@ -71,6 +71,8 @@ public sealed override long Position
 
         public sealed override bool IsBufferComplete => true;
 
+        protected static int MaxLineLen => MAX_LINE_LEN;
+
         #endregion
 
         #region Public methods
@@ -90,7 +92,10 @@ protected override void Dispose(bool disposing)
 
         public override unsafe int ReadChar()
         {
-            if (IsDisposed) throw new ObjectDisposedException(ToString());
+            if (IsDisposed)
+            {
+                throw new ObjectDisposedException(ToString());
+            }
 
             try
             {
@@ -154,7 +159,7 @@ private int DetectPreambleLengthAndEncoding(out Encoding detectedEncoding)
             int readLen = _stream.Read(readPreamble, 0, 4);
             if (readLen >= 2)
             {
-                foreach (Encoding encoding in PositionAwareStreamReaderBase._preambleEncodings)
+                foreach (Encoding encoding in _preambleEncodings)
                 {
                     byte[] preamble = encoding.GetPreamble();
                     bool fail = false;
@@ -180,7 +185,7 @@ private int DetectPreambleLengthAndEncoding(out Encoding detectedEncoding)
             return 0;
         }
 
-        private Encoding getUsedEncoding(EncodingOptions encodingOptions, Encoding detectedEncoding)
+        private Encoding GetUsedEncoding(EncodingOptions encodingOptions, Encoding detectedEncoding)
         {
             if (encodingOptions.Encoding != null)
             {
@@ -192,26 +197,25 @@ private Encoding getUsedEncoding(EncodingOptions encodingOptions, Encoding detec
                 return detectedEncoding;
             }
 
-            if (encodingOptions.DefaultEncoding != null)
-            {
-                return encodingOptions.DefaultEncoding;
-            }
-
-            return Encoding.Default;
+            return encodingOptions.DefaultEncoding ?? Encoding.Default;
         }
-        private int getPosIncPrecomputed(Encoding usedEncoding)
+        private int GetPosIncPrecomputed(Encoding usedEncoding)
         {
-            if (usedEncoding is UTF8Encoding)
+            switch (usedEncoding)
             {
-                return 0;
-            }
-
-            if (usedEncoding is UnicodeEncoding)
-            {
-                return 2;
+                case UTF8Encoding _:
+                {
+                    return 0;
+                }
+                case UnicodeEncoding _:
+                {
+                    return 2;
+                }
+                default:
+                {
+                    return 1;
+                }
             }
-
-            return 1;
         }
 
         #endregion