fix: propagate producer exceptions through Channel in FillDataTableAsync

- channel.Writer.Complete(fault) passes the exception to the consumer
  immediately instead of silently completing with no data
- Add onError: Action<Exception> parameter so the caller can show
  MessageBox.Show(ex.Message) instead of the exception being swallowed
  in async void button click handlers

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

Author: vkuttyp

src/SqlDotnetty.Core/ISqlDatabase.cs

@@ -177,21 +177,28 @@ public static System.Data.DataRow ToDataRow(this SqlRow row)
     /// Optional callback invoked on the UI thread after each batch is flushed.
     /// Receives the total number of rows added so far. Use to update a label, progress bar, etc.
     /// </param>
+    /// <param name="onError">
+    /// Optional callback invoked on the UI thread if the producer encounters an error.
+    /// Receives the exception. If not provided, the exception is re-thrown from the awaited task.
+    /// </param>
     /// <param name="ct">Cancellation token.</param>
     /// <example>
     /// <code>
     /// var dt = new DataTable();
     /// dataGridView1.DataSource = dt;
     ///
     /// await conn.QueryStreamAsync("SELECT * FROM BigTable")
-    ///           .FillDataTableAsync(dt, onProgress: n => label1.Text = $"{n} rows loaded");
+    ///           .FillDataTableAsync(dt,
+    ///               onProgress: n => label1.Text = $"{n} rows loaded",
+    ///               onError:    ex => MessageBox.Show(ex.Message));
     /// </code>
     /// </example>
     public static async Task FillDataTableAsync(
         this IAsyncEnumerable<SqlRow> rows,
         System.Data.DataTable table,
         int batchSize = 500,
         Action<int>? onProgress = null,
+        Action<Exception>? onError = null,
         CancellationToken ct = default)
     {
         // Bounded channel: producer (background) reads network; consumer (UI thread) flushes batches.
@@ -207,6 +214,7 @@ public static async Task FillDataTableAsync(
         // Producer: run network I/O on a thread-pool thread so the UI is never blocked.
         var producer = Task.Run(async () =>
         {
+            Exception? fault = null;
             try
             {
                 var batch = new List<SqlRow>(batchSize);
@@ -222,24 +230,39 @@ public static async Task FillDataTableAsync(
                 if (batch.Count > 0)
                     await channel.Writer.WriteAsync(batch, ct).ConfigureAwait(false);
             }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                fault = ex;
+            }
             finally
             {
-                channel.Writer.Complete();
+                // Pass the exception into the channel so the consumer sees it immediately
+                // instead of silently completing with no data.
+                channel.Writer.Complete(fault);
             }
         }, ct);
 
         // Consumer: runs on the calling (UI) thread — no ConfigureAwait(false).
         // await Task.Yield() between batches lets the message pump process redraws/clicks.
         int totalRows = 0;
-        await foreach (var batch in channel.Reader.ReadAllAsync(ct))
+        try
+        {
+            await foreach (var batch in channel.Reader.ReadAllAsync(ct))
+            {
+                FlushBatch(table, batch);
+                totalRows += batch.Count;
+                onProgress?.Invoke(totalRows);
+                await Task.Yield();
+            }
+        }
+        catch (Exception ex) when (onError != null)
         {
-            FlushBatch(table, batch);
-            totalRows += batch.Count;
-            onProgress?.Invoke(totalRows);
-            await Task.Yield();
+            // Surface the error on the UI thread via the callback instead of throwing.
+            onError(ex);
+            return;
         }
 
-        // Propagate any producer exception (e.g. network error) to the caller.
+        // Propagate any producer exception to the caller when no onError handler is set.
         await producer;
     }