Add clear and restore functionality to RichTextBoxSink

Author: vonhoff

Demo/Form1.Designer.cs

@@ -33,6 +33,7 @@ namespace Demo
     public partial class Form1 : Form
     {
         private RichTextBoxSinkOptions? _options;
+        private RichTextBoxSink? _sink;
         private bool _toolbarsVisible = true;
 
         public Form1()
@@ -47,10 +48,10 @@ private void Initialize()
                 outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:l}{NewLine}{Exception}",
                 formatProvider: new CultureInfo("en-US"));
 
-            var sink = new RichTextBoxSink(richTextBox1, _options);
+            _sink = new RichTextBoxSink(richTextBox1, _options);
             Log.Logger = new LoggerConfiguration()
                 .MinimumLevel.Verbose()
-                .WriteTo.Sink(sink, LogEventLevel.Verbose)
+                .WriteTo.Sink(_sink, LogEventLevel.Verbose)
                 .CreateLogger();
 
             Log.Debug("Started logger.");
@@ -337,5 +338,25 @@ private void Form1_KeyDown(object sender, KeyEventArgs e)
                 toolStrip2.Visible = _toolbarsVisible;
             }
         }
+
+        private void btnClear_Click(object sender, EventArgs e)
+        {
+            if (_sink == null)
+            {
+                return;
+            }
+
+            _sink.Clear();
+        }
+
+        private void btnRestore_Click(object sender, EventArgs e)
+        {
+            if (_sink == null)
+            {
+                return;
+            }
+
+            _sink.Restore();
+        }
     }
 }

Demo/Form1.cs

@@ -2,18 +2,20 @@
 
 namespace Serilog.Sinks.RichTextBoxForms.Collections
 {
-    internal sealed class ConcurrentCircularBuffer<T>
+    public sealed class ConcurrentCircularBuffer<T>
     {
         private readonly object _sync = new();
         private readonly T[] _buffer;
         private readonly int _capacity;
         private int _head;
         private int _count;
+        private int _itemsToSkip;
 
         public ConcurrentCircularBuffer(int capacity)
         {
             _capacity = capacity > 0 ? capacity : 1;
             _buffer = new T[_capacity];
+            _itemsToSkip = 0;
         }
 
         public void Add(T item)
@@ -33,6 +35,11 @@ public void Add(T item)
                     {
                         _head = 0;
                     }
+
+                    if (_itemsToSkip > 0)
+                    {
+                        _itemsToSkip--;
+                    }
                 }
                 else
                 {
@@ -47,9 +54,15 @@ public void TakeSnapshot(List<T> target)
             {
                 target.Clear();
 
-                for (var i = 0; i < _count; ++i)
+                var itemsToTake = _count - _itemsToSkip;
+                if (itemsToTake <= 0)
                 {
-                    var index = _head + i;
+                    return;
+                }
+
+                for (var i = 0; i < itemsToTake; ++i)
+                {
+                    var index = _head + _itemsToSkip + i;
                     if (index >= _capacity)
                     {
                         index -= _capacity;
@@ -59,5 +72,21 @@ public void TakeSnapshot(List<T> target)
                 }
             }
         }
+
+        public void Clear()
+        {
+            lock (_sync)
+            {
+                _itemsToSkip = _count;
+            }
+        }
+
+        public void Restore()
+        {
+            lock (_sync)
+            {
+                _itemsToSkip = 0;
+            }
+        }
     }
 }

Serilog.Sinks.RichTextBox.WinForms.Colored/Sinks/RichTextBoxForms/Collections/ConcurrentCircularBuffer.cs

@@ -78,6 +78,23 @@ public void Dispose()
         public void Emit(LogEvent logEvent)
         {
             _buffer.Add(logEvent);
+            Update();
+        }
+
+        public void Clear()
+        {
+            _buffer.Clear();
+            Update();
+        }
+
+        public void Restore()
+        {
+            _buffer.Restore();
+            Update();
+        }
+
+        private void Update()
+        {
             Interlocked.Exchange(ref _hasNewMessages, 1);
             _signal.Set();
         }
@@ -107,8 +124,6 @@ private void ProcessMessages(CancellationToken token)
                     }
 
                     Interlocked.Exchange(ref _hasNewMessages, 0);
-
-                    // Take a snapshot of the current buffer
                     _buffer.TakeSnapshot(snapshot);
                     builder.Clear();
                     foreach (var evt in snapshot)