Enhance async methods and update DBNull handling

- Updated `RetrieveAsync` in `ExpressiveDbCommandBase` to support `IEnumerable<int>` for .NET 8+ while preserving previous behavior.
- Modified `AsEnumerable` in `DataReaderExtensions` to accept `IEnumerable<int>` for .NET 8+, with documentation improvements.
- Renamed `CopyToWithDbNullAsNull` to `CopyToDBNullAsNull` in `CoreExtensions` for consistency, updating related overloads.
- Streamlined `ReplaceDBNullWithNull` to utilize the new `CopyToDBNullAsNull` method.
- Added a new overload of `ReplaceDBNullWithNull` for `List<object?>` to handle `DBNull` values directly.
- Updated `To<T>` method in `CoreExtensions` to accept `IEnumerable<(string Field, string? Column)>` for .NET 8+, maintaining previous overload for earlier versions.

Author: electricessence

Source/Core/ExpressiveDbCommandBase.cs

@@ -207,8 +207,13 @@ public ValueTask<IEnumerable<T0>> FirstOrdinalResultsAsync<T0>()
 	/// <param name="n">The first ordinal to include in the request to the reader for each record.</param>
 	/// <param name="others">The remaining ordinals to request from the reader for each record.</param>
 	/// <returns>The QueryResult that contains all the results and the column mappings.</returns>
+#if NET8_0_OR_GREATER
+	public ValueTask<QueryResultQueue<object[]>> RetrieveAsync(int n, params IEnumerable<int> others)
+		=> RetrieveAsync(others.Prepend(n));
+#else
 	public ValueTask<QueryResultQueue<object[]>> RetrieveAsync(int n, params int[] others)
 		=> RetrieveAsync(Concat(n, others));
+#endif
 
 	/// <summary>
 	/// Iterates all records within the current result set using an IDataReader and returns the desired results.

Source/Core/Extensions/DataReader.cs

@@ -273,19 +273,25 @@ internal static IEnumerable<object[]> AsEnumerableInternal(
 	public static IEnumerable<object[]> AsEnumerable(this IDataReader reader, IEnumerable<int> ordinals)
 		=> AsEnumerableInternal(reader, ordinals, false);
 
-	/// <param name="reader">The reader to enumerate.</param>
-	/// <param name="ordinals">The limited set of ordinals to include.  If none are specified, the returned objects will be empty.</param>
-	/// <param name="arrayPool">The array pool to acquire buffers from.</param>
-	/// <inheritdoc cref="AsEnumerable(IDataReader, ArrayPool{object?}, int, int[])"/>
-	public static IEnumerable<object[]> AsEnumerable(this IDataReader reader, IEnumerable<int> ordinals, ArrayPool<object>? arrayPool)
-		=> AsEnumerableInternal(reader, ordinals, false, arrayPool);
-
 	/// <param name="reader">The reader to enumerate.</param>
 	/// <param name="n">The first ordinal to include in the request to the reader for each record.</param>
 	/// <param name="others">The remaining ordinals to request from the reader for each record.</param>
 	/// <inheritdoc cref="AsEnumerable(IDataReader, ArrayPool{object?}, int, int[])"/>
+#if NET8_0_OR_GREATER
+	public static IEnumerable<object[]> AsEnumerable(this IDataReader reader, int n, params IEnumerable<int> others)
+		=> AsEnumerableInternal(reader, others.Prepend(n), false);
+#else
+
 	public static IEnumerable<object[]> AsEnumerable(this IDataReader reader, int n, params int[] others)
 		=> AsEnumerable(reader, CoreExtensions.Concat(n, others));
+#endif
+
+	/// <param name="reader">The reader to enumerate.</param>
+	/// <param name="ordinals">The limited set of ordinals to include.  If none are specified, the returned objects will be empty.</param>
+	/// <param name="arrayPool">The array pool to acquire buffers from.</param>
+	/// <inheritdoc cref="AsEnumerable(IDataReader, ArrayPool{object?}, int, int[])"/>
+	public static IEnumerable<object[]> AsEnumerable(this IDataReader reader, IEnumerable<int> ordinals, ArrayPool<object>? arrayPool)
+		=> AsEnumerableInternal(reader, ordinals, false, arrayPool);
 
 	/// <summary>
 	/// Provides an enumerable for iterating all the remaining values of the current result set of a data reader.

Source/Core/Extensions/_.cs

@@ -31,7 +31,7 @@ internal static IEnumerable<T> Concat<T>(T first, ICollection<T> remaining)
 	/// to the <paramref name="target"/> span
 	/// with any <see cref="DBNull"/> values converted to <see langword="null"/>.
 	/// </summary>
-	public static Span<object?> CopyToWithDbNullAsNull(this ReadOnlySpan<object?> values, Span<object?> target)
+	public static Span<object?> CopyToDBNullAsNull(this ReadOnlySpan<object?> values, Span<object?> target)
 	{
 		int len = values.Length;
 		object?[] result = new object?[len];
@@ -41,9 +41,18 @@ internal static IEnumerable<T> Concat<T>(T first, ICollection<T> remaining)
 		return result;
 	}
 
-	/// <inheritdoc cref="CopyToWithDbNullAsNull(ReadOnlySpan{object?}, Span{object?})"/>
-	public static Span<object?> CopyToWithDbNullAsNull(this Span<object?> values, Span<object?> target)
-		=> CopyToWithDbNullAsNull((ReadOnlySpan<object?>)values, target);
+	/// <inheritdoc cref="CopyToDBNullAsNull(ReadOnlySpan{object?}, Span{object?})"/>
+	public static Span<object?> CopyToDBNullAsNull(this Span<object?> values, Span<object?> target)
+		=> CopyToDBNullAsNull((ReadOnlySpan<object?>)values, target);
+
+
+	/// <inheritdoc cref="CopyToDBNullAsNull(ReadOnlySpan{object?}, Span{object?})"/>
+	public static Span<object?> CopyToDBNullAsNull(this ReadOnlySpan<object?> values, Memory<object?> target)
+		=> CopyToDBNullAsNull(values, target.Span);
+
+	/// <inheritdoc cref="CopyToDBNullAsNull(ReadOnlySpan{object?}, Span{object?})"/>
+	public static Span<object?> CopyToDBNullAsNull(this Span<object?> values, Memory<object?> target)
+		=> CopyToDBNullAsNull((ReadOnlySpan<object?>)values, target.Span);
 
 	/// <summary>
 	/// Any <see cref="DBNull"/> values are yielded as null.
@@ -70,7 +79,7 @@ internal static IEnumerable<T> Concat<T>(T first, ICollection<T> remaining)
 		Contract.EndContractBlock();
 
 		object?[] result = new object?[values.Length];
-		CopyToWithDbNullAsNull(values.AsSpan(), result.AsSpan());
+		CopyToDBNullAsNull(values.AsSpan(), result.AsSpan());
 		return result;
 	}
 
@@ -81,7 +90,7 @@ internal static IEnumerable<T> Concat<T>(T first, ICollection<T> remaining)
 	public static object?[] DBNullToNullCopy(this ReadOnlySpan<object?> values)
 	{
 		object?[] result = new object?[values.Length];
-		DBNullToNullCopy(values, result.AsSpan());
+		CopyToDBNullAsNull(values, result.AsSpan());
 		return result;
 	}
 
@@ -94,7 +103,14 @@ internal static IEnumerable<T> Concat<T>(T first, ICollection<T> remaining)
 	/// </summary>
 	/// <param name="values">The source values.</param>
 	public static Span<object?> ReplaceDBNullWithNull(this Span<object?> values)
-		=> DBNullToNullCopy(values, values);
+		=> CopyToDBNullAsNull(values, values);
+
+	/// <inheritdoc cref="ReplaceDBNullWithNull(Span{object?})"/>
+	public static Memory<object?> ReplaceDBNullWithNull(this Memory<object?> values)
+	{
+		CopyToDBNullAsNull(values.Span, values.Span);
+		return values;
+	}
 
 	/// <inheritdoc cref="ReplaceDBNullWithNull(Span{object?})"/>
 	public static object?[] ReplaceDBNullWithNull(this object?[] values)
@@ -106,6 +122,30 @@ internal static IEnumerable<T> Concat<T>(T first, ICollection<T> remaining)
 		return values;
 	}
 
+	/// <inheritdoc cref="ReplaceDBNullWithNull(Span{object?})"/>
+	public static List<object?> ReplaceDBNullWithNull(this List<object?> values)
+	{
+		if (values is null) throw new ArgumentNullException(nameof(values));
+		Contract.EndContractBlock();
+
+#if NET8_0_OR_GREATER
+		var span = System.Runtime.InteropServices.CollectionsMarshal.AsSpan(values);
+		for (int i = 0; i < span.Length; i++)
+		{
+			ref object? item = ref span[i];
+			if (item == DBNull.Value) item = null;
+		}
+#else
+		int count = values.Count;
+		for (int i = 0; i < count; i++)
+		{
+			if (values[i] == DBNull.Value) values[i] = null;
+		}
+#endif
+
+		return values;
+	}
+
 	/// <summary>
 	/// Generic enumerable extension for <see cref="DataColumnCollection"/>.
 	/// </summary>
@@ -149,7 +189,11 @@ static IEnumerable<DataRow> AsEnumerableCore(DataRowCollection rows)
 		.Results(table, clearSourceTable);
 
 	/// <inheritdoc cref="To{T}(DataTable, IEnumerable{KeyValuePair{string, string?}}?, bool)"/>
+#if NET8_0_OR_GREATER
+	public static IEnumerable<T> To<T>(this DataTable table, params IEnumerable<(string Field, string? Column)> fieldMappingOverrides) where T : new()
+#else
 	public static IEnumerable<T> To<T>(this DataTable table, params (string Field, string? Column)[] fieldMappingOverrides) where T : new()
+#endif
 		=> Transformer<T>
 		.Create(fieldMappingOverrides)
 		.Results(table, false);