refactor: migrate DataReader/DataRow extensions to System.Text.Json

Replace Newtonsoft.Json with System.Text.Json for better performance.
Remove KustoJsonSerializerHelper and custom Newtonsoft converters.
Add shared KustoJsonSerializerOptions for consistent configuration.

Author: Per Kops

src/Atc.Kusto/Extensions/DataReaderExtensions.cs

@@ -2,28 +2,75 @@
 namespace Atc.Kusto;
 
 /// <summary>
-/// Provides extension methods for reading and converting data from an <see cref="IDataReader"/> to objects using Newtonsoft.Json.
+/// Provides extension methods for reading and converting data from an <see cref="IDataReader"/> to objects using System.Text.Json.
 /// These methods simplify the process of converting database records into strongly-typed objects.
+/// Note: Newtonsoft.Json.Linq is retained for handling <see cref="JToken"/> objects returned by the Kusto SDK for dynamic fields.
 /// </summary>
 public static class DataReaderExtensions
 {
     /// <summary>
     /// Reads all rows from the <see cref="IDataReader"/> and converts them into an array of strongly-typed objects of type <typeparamref name="T"/>.
-    /// The conversion is handled using Newtonsoft.Json with a custom converter to facilitate the transition between Newtonsoft.Json and System.Text.Json.
+    /// The conversion is handled using System.Text.Json for optimal performance.
     /// </summary>
     /// <typeparam name="T">The type of objects to convert the data into.</typeparam>
     /// <param name="reader">The <see cref="IDataReader"/> from which to read the data.</param>
+    /// <param name="options">Optional JSON serializer options. If not provided, default options with enum string conversion, case-insensitive property matching, and number string reading will be used.</param>
     /// <returns>An array of objects of type <typeparamref name="T"/> representing the data read from the reader.</returns>
     public static T[] ReadObjects<T>(
-        this IDataReader reader)
+        this IDataReader reader,
+        JsonSerializerOptions? options = null)
     {
         ArgumentNullException.ThrowIfNull(reader);
 
-        return reader
-            .ToJObjects()
-            .Select(o => o.ToObject<T>(KustoJsonSerializerHelper.Serializer))
-            .OfType<T>()
-            .ToArray();
+        options ??= KustoJsonSerializerOptions.Default;
+
+        var buffer = new ArrayBufferWriter<byte>();
+        using var doc = new Utf8JsonWriter(buffer);
+        var results = new List<T>();
+
+        while (reader.Read())
+        {
+            buffer.Clear();
+            doc.Reset(buffer);
+
+            doc.WriteStartObject();
+
+            for (var i = 0; i < reader.FieldCount; i++)
+            {
+                var value = reader.GetValue(i);
+
+                var name = reader.GetName(i);
+                if (options.PropertyNamingPolicy is { } np)
+                {
+                    name = np.ConvertName(name);
+                }
+
+                doc.WritePropertyName(name);
+
+                switch (value)
+                {
+                    case JToken token:
+                        doc.WriteRawValue(token.ToString(Newtonsoft.Json.Formatting.None));
+                        break;
+                    case DBNull:
+                        doc.WriteNullValue();
+                        break;
+                    case SqlDecimal sd:
+                        doc.WriteNumberValue(sd.ToDecimal());
+                        break;
+                    default:
+                        JsonSerializer.Serialize(doc, value, options);
+                        break;
+                }
+            }
+
+            doc.WriteEndObject();
+            doc.Flush();
+
+            results.Add(JsonSerializer.Deserialize<T>(buffer.WrittenSpan, options)!);
+        }
+
+        return [.. results];
     }
 
     /// <summary>

src/Atc.Kusto/Extensions/DataRowExtensions.cs

@@ -1,4 +1,4 @@
-// ReSharper disable CheckNamespace
+// ReSharper disable CheckNamespace
 namespace Atc.Kusto;
 
 /// <summary>
@@ -8,23 +8,40 @@ public static class DataRowExtensions
 {
     /// <summary>
     /// Maps the specified <see cref="DataRow"/> to an object of type <typeparamref name="T"/>.
-    /// The mapping is performed by converting the row's values to a JSON object using a shared serializer.
+    /// The mapping is performed by converting the row's values to JSON using System.Text.Json
+    /// and then deserializing to the target type.
+    /// Special handling is provided for SqlDecimal values returned by Kusto to ensure proper conversion.
     /// </summary>
     /// <typeparam name="T">The target type to which the row is mapped.</typeparam>
     /// <param name="row">The data row to map.</param>
+    /// <param name="options">Optional JSON serializer options. If not provided, default options with enum string conversion and case-insensitive property matching will be used.</param>
     /// <returns>An instance of type <typeparamref name="T"/> created from the DataRow.</returns>
-    public static T? MapDataRow<T>(this DataRow row)
+    public static T? MapDataRow<T>(this DataRow row, JsonSerializerOptions? options = null)
     {
         ArgumentNullException.ThrowIfNull(row);
 
+        options ??= KustoJsonSerializerOptions.Default;
+
         // Convert the DataRow to a dictionary using its columns.
+        // Pre-process values to handle SqlDecimal and DBNull since System.Text.Json doesn't support them.
         var dict = row.Table.Columns
             .Cast<DataColumn>()
-            .ToDictionary(col => col.ColumnName, col => row[col], StringComparer.Ordinal);
-
-        // Create a JObject from the dictionary using the shared serializer.
-        var jObject = Newtonsoft.Json.Linq.JObject.FromObject(dict, KustoJsonSerializerHelper.Serializer);
+            .ToDictionary(
+                col => col.ColumnName,
+                col =>
+                {
+                    var value = row[col];
+                    return value switch
+                    {
+                        SqlDecimal sd => sd.ToDecimal(),
+                        DBNull => null,
+                        _ => value,
+                    };
+                },
+                StringComparer.Ordinal);
 
-        return jObject.ToObject<T>(KustoJsonSerializerHelper.Serializer);
+        // Serialize to JSON and deserialize to the target type using System.Text.Json.
+        var json = JsonSerializer.Serialize(dict, options);
+        return JsonSerializer.Deserialize<T>(json, options);
     }
 }

src/Atc.Kusto/Serialization/Internal/KustoJsonSerializerHelper.cs

@@ -0,0 +1,18 @@
+namespace Atc.Kusto.Utilities.Internal;
+
+/// <summary>
+/// Provides shared JSON serializer options for consistent Kusto data deserialization across the library.
+/// </summary>
+internal static class KustoJsonSerializerOptions
+{
+    /// <summary>
+    /// Gets the default JSON serializer options configured for Kusto data deserialization.
+    /// Includes enum string conversion, case-insensitive property matching, and support for reading numbers from strings.
+    /// </summary>
+    public static JsonSerializerOptions Default { get; } = new()
+    {
+        Converters = { new JsonStringEnumConverter() },
+        PropertyNameCaseInsensitive = true,
+        NumberHandling = JsonNumberHandling.AllowReadingFromString,
+    };
+}

src/Atc.Kusto/Serialization/Internal/NewtonsoftDecimalConverter.cs

@@ -33,6 +33,10 @@ public void ReadObjects_Will_Return_Objects_Read_From_DataReader(
             .GetValues(null!)
             .ReturnsForAnyArgs(c => c.Arg<object[]>().CopyFrom(values[index], 0));
 
+        dataReader
+            .GetValue(0)
+            .ReturnsForAnyArgs(c => values[index][c.Arg<int>()]);
+
         // Act
         var actual = dataReader.ReadObjects<TestObject>();
 
@@ -66,6 +70,10 @@ public void CanReadObjects(
             .GetValues(null!)
             .ReturnsForAnyArgs(c => c.Arg<object[]>().CopyFrom(values[index], 0));
 
+        dataReader
+            .GetValue(0)
+            .ReturnsForAnyArgs(c => values[index][c.Arg<int>()]);
+
         dataReader
             .NextResult()
             .Returns(true);