Keep items whose ToString() is null in ToStringEnumerable and Join [patch]

Extensions.Test/EnumerableExtensionsTests.cs

@@ -456,4 +456,42 @@
 
 		Assert.ThrowsExactly<InvalidOperationException>(() => result.ToList());
 	}
+
+	private sealed class NullToString
+	{
+		public override string? ToString() => null;
+	}
+
+	[TestMethod]
+	[DataRow(NullItemHandling.Remove)]
+	[DataRow(NullItemHandling.Include)]
+	[DataRow(NullItemHandling.Throw)]
+	public void ToStringEnumerableKeepsAnItemWhoseToStringIsNullAsEmpty(NullItemHandling nullItemHandling)
+	{
+		object[] items = [new NullToString(), "x"];
+
+		List<string?> result = [.. items.ToStringEnumerable(nullItemHandling)];
+
+		CollectionAssert.AreEqual(new List<string?> { string.Empty, "x" }, result);
+	}
+
+	[TestMethod]
+	public void ToStringEnumerableWithoutHandlingKeepsAnItemWhoseToStringIsNullAsEmpty()
+	{
+		object[] items = [new NullToString(), "x"];
+
+		List<string> result = [.. items.ToStringEnumerable()];
+
+		CollectionAssert.AreEqual(new List<string> { string.Empty, "x" }, result);
+	}
+
+	[TestMethod]
+	[DataRow(NullItemHandling.Remove)]
+	[DataRow(NullItemHandling.Include)]
+	public void JoinMatchesToStringEnumerableForTheSameHandling(NullItemHandling nullItemHandling)
+	{
+		object?[] items = [new NullToString(), null, "x"];
+
+		Assert.AreEqual(string.Join(",", items.ToStringEnumerable(nullItemHandling)), items.Join(",", nullItemHandling));
+	}
 }

Extensions/EnumerableExtensions.cs

@@ -30,7 +30,7 @@
 #pragma warning disable KTSU0004 // Use Ensure.NotNull instead of manual null check
 		if (items is null)
 		{
 			throw new ArgumentNullException(nameof(items), "Items cannot be null.");
 		}
 #pragma warning restore KTSU0004 // Use Ensure.NotNull instead of manual null check
 
@@ -190,7 +190,10 @@
 	/// <typeparam name="T">The type of the items in the enumerable.</typeparam>
 	/// <param name="items">The enumerable to convert.</param>
 	/// <param name="nullItemHandling">Specifies how to handle null items.</param>
-	/// <returns>An enumerable of strings.</returns>
+	/// <returns>
+	/// An enumerable of strings. <paramref name="nullItemHandling"/> applies to null items only; a non-null item whose
+	/// <see cref="object.ToString"/> returns null is always kept, as an empty string.
+	/// </returns>
 	/// <exception cref="InvalidOperationException">Thrown while enumerating the result if <paramref name="nullItemHandling"/> is set to <see cref="NullItemHandling.Throw"/> and the enumerable contains null items.</exception>
 	public static IEnumerable<string?> ToStringEnumerable<T>(this IEnumerable<T> items, NullItemHandling nullItemHandling)
 	{
@@ -203,9 +206,11 @@
 
 		// The argument check above stays eager; the null check happens during the one enumeration the
 		// caller makes, so a single-pass source is not consumed early and a null added later is caught.
+		// Null handling tests the item, not its string: an item whose ToString() returns null becomes "".
 		return items
-			.Select(item => ThrowIfNullItem(item, nullItemHandling)?.ToString())
-			.Where(item => nullItemHandling is NullItemHandling.Include || item is not null);
+			.Select(item => ThrowIfNullItem(item, nullItemHandling))
+			.Where(item => nullItemHandling is NullItemHandling.Include || item is not null)
+			.Select(item => item is null ? null : item.ToString() ?? string.Empty);
 	}
 
 	/// <summary>
@@ -260,10 +265,7 @@
 		}
 #pragma warning restore KTSU0004 // Use Ensure.NotNull instead of manual null check
 
-		return string.Join(separator, items
-			.Select(item => ThrowIfNullItem(item, nullItemHandling))
-			.Where(item => nullItemHandling is NullItemHandling.Include || item is not null)
-			.Select(i => i?.ToString()));
+		return string.Join(separator, items.ToStringEnumerable(nullItemHandling));
 	}
 
 	/// <summary>