Improve OCTV streaming performance

- Coalesce Application.Invoke() calls: only one UI notification
  in-flight at a time, batching all rows added between dispatches
- Skip data source copy when no filter is active (OnDataChanged
  points table directly at master source)
- Filter(") returns this instead of copying all rows
- Compile regex once per filter operation instead of per-cell
- Cache ColumnNames array at construction time

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: tig

src/Microsoft.PowerShell.ConsoleGuiTools/OutConsoleTableView.cs

@@ -26,6 +26,7 @@ internal sealed class OutConsoleTableView : IDisposable
     private List<DataTableColumn>? _columns;
     private OutTableViewDataSource? _dataSource;
     private int _objectIndex;
+    private int _pendingNotify; // 0 = no pending UI update, 1 = scheduled
     private HashSet<int>? _result;
     private Thread? _uiThread;
     private OutTableViewWindow? _window;
@@ -66,8 +67,14 @@ public void AddObject(PSObject psObject)
             _dataSource!.AddRow(row);
         }
 
-        // Notify UI thread of new data
-        _app?.Invoke(() => _window?.OnDataChanged());
+        // Coalesce UI notifications: only schedule one Invoke at a time.
+        // When it fires it picks up ALL rows added since the last notification.
+        if (Interlocked.CompareExchange(ref _pendingNotify, 1, 0) == 0)
+            _app?.Invoke(() =>
+            {
+                Interlocked.Exchange(ref _pendingNotify, 0);
+                _window?.OnDataChanged();
+            });
     }
 
     /// <summary>

src/Microsoft.PowerShell.ConsoleGuiTools/OutTableViewDataSource.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
+using System.Threading;
 using Microsoft.PowerShell.OutGridView.Models;
 using Terminal.Gui.Views;
 
@@ -16,15 +17,16 @@ namespace Microsoft.PowerShell.ConsoleGuiTools;
 internal sealed class OutTableViewDataSource : ITableSource
 {
     private readonly List<DataTableColumn> _columns;
+    private readonly Lock _lock = new();
     private readonly List<DataTableRow> _rows;
-    private readonly object _lock = new();
 
     /// <summary>
     ///     Creates an empty data source with the specified columns.
     /// </summary>
     public OutTableViewDataSource(List<DataTableColumn> columns)
     {
         _columns = columns;
+        ColumnNames = columns.Select(c => c.Label).ToArray();
         _rows = new List<DataTableRow>();
     }
 
@@ -34,19 +36,26 @@ public OutTableViewDataSource(List<DataTableColumn> columns)
     public OutTableViewDataSource(List<DataTableColumn> columns, List<DataTableRow> rows)
     {
         _columns = columns;
+        ColumnNames = columns.Select(c => c.Label).ToArray();
         _rows = new List<DataTableRow>(rows);
     }
 
     /// <inheritdoc />
-    public string[] ColumnNames => _columns.Select(c => c.Label).ToArray();
+    public string[] ColumnNames { get; }
 
     /// <inheritdoc />
     public int Columns => _columns.Count;
 
     /// <inheritdoc />
     public int Rows
     {
-        get { lock (_lock) return _rows.Count; }
+        get
+        {
+            lock (_lock)
+            {
+                return _rows.Count;
+            }
+        }
     }
 
     /// <inheritdoc />
@@ -73,64 +82,63 @@ public int Rows
     /// </summary>
     public void AddRow(DataTableRow row)
     {
-        lock (_lock) _rows.Add(row);
+        lock (_lock)
+        {
+            _rows.Add(row);
+        }
     }
 
     /// <summary>
     ///     Gets the original object index for the specified row.
     /// </summary>
     public int GetOriginalObjectIndex(int row)
     {
-        lock (_lock) return row >= 0 && row < _rows.Count ? _rows[row].OriginalObjectIndex : -1;
+        lock (_lock)
+        {
+            return row >= 0 && row < _rows.Count ? _rows[row].OriginalObjectIndex : -1;
+        }
     }
 
     /// <summary>
-    ///     Gets a snapshot of all rows.
+    ///     Gets the column definitions.
     /// </summary>
-    public List<DataTableRow> GetAllRows()
+    public List<DataTableColumn> GetColumns()
     {
-        lock (_lock) return new List<DataTableRow>(_rows);
+        return _columns;
     }
 
-    /// <summary>
-    ///     Gets the column definitions.
-    /// </summary>
-    public List<DataTableColumn> GetColumns() => _columns;
-
     /// <summary>
     ///     Creates a new filtered data source containing only rows matching the regex pattern.
+    ///     Returns itself if the pattern is empty (no copy needed).
     /// </summary>
     public OutTableViewDataSource Filter(string pattern)
     {
-        List<DataTableRow> allRows;
-        lock (_lock) allRows = new List<DataTableRow>(_rows);
-
         if (string.IsNullOrEmpty(pattern))
-            return new OutTableViewDataSource(_columns, allRows);
+            return this;
 
-        var result = allRows.Where(r => RowMatchesFilter(r, pattern)).ToList();
+        var regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
 
-        return new OutTableViewDataSource(_columns, result);
-    }
+        List<DataTableRow> allRows;
+        lock (_lock)
+        {
+            allRows = new List<DataTableRow>(_rows);
+        }
 
-    /// <summary>
-    ///     Creates a data source from an existing <see cref="DataTable" />.
-    /// </summary>
-    public static OutTableViewDataSource FromDataTable(DataTable dataTable)
-    {
-        return new OutTableViewDataSource(dataTable.DataColumns, dataTable.Data);
+        var result = allRows.Where(r => RowMatchesFilter(r, regex, _columns)).ToList();
+
+        return new OutTableViewDataSource(_columns, result);
     }
 
-    private bool RowMatchesFilter(DataTableRow row, string pattern)
+    private static bool RowMatchesFilter(DataTableRow row, Regex regex, List<DataTableColumn> columns)
     {
-        foreach (var column in _columns)
+        foreach (var column in columns)
         {
             var columnKey = column.ToString();
             if (row.Values.TryGetValue(columnKey, out var value) &&
-                Regex.IsMatch(value.DisplayValue, pattern, RegexOptions.IgnoreCase))
+                regex.IsMatch(value.DisplayValue))
                 return true;
         }
 
         return false;
     }
-}
+}

src/Microsoft.PowerShell.ConsoleGuiTools/OutTableViewWindow.cs

@@ -117,7 +117,21 @@ protected override void OnIsRunningChanged(bool newIsRunning)
     /// </summary>
     public void OnDataChanged()
     {
-        ApplyFilter();
+        if (string.IsNullOrEmpty(_applicationData.Filter))
+        {
+            // No filter active — just point the table at the master source directly (no copy)
+            if (_filteredDataSource != _masterDataSource)
+            {
+                _filteredDataSource = _masterDataSource;
+                _tableView!.Table = _filteredDataSource;
+            }
+            _tableView?.Update();
+        }
+        else
+        {
+            ApplyFilter();
+        }
+
         if (_isLoading)
             _rowsShortcut.Text = $"{_masterDataSource.Rows} rows";
     }
@@ -214,7 +228,7 @@ private void ApplySearch()
             {
                 for (var col = 0; col < _filteredDataSource.Columns; col++)
                 {
-                    var cellValue = _filteredDataSource[row, col]?.ToString() ?? string.Empty;
+                    var cellValue = _filteredDataSource[row, col].ToString() ?? string.Empty;
                     if (regex.IsMatch(cellValue))
                     {
                         _tableView.SetSelection(0, row, false);