Add NullOrEmpty and NullOrWhiteSpace overloads for ReadOnlySpan<char>

src/GuardClauses/GuardAgainstEmptyOrWhiteSpaceExtensions.cs

@@ -0,0 +1,52 @@
+using System;
+
+namespace Ardalis.GuardClauses
+{
+    public static partial class GuardClauseExtensions
+    {
+#if NET5_0_OR_GREATER
+        /// <summary>
+        /// Throws an <see cref="ArgumentException" /> if <paramref name="input" /> is an empty string.
+        /// </summary>
+        /// <param name="guardClause"></param>
+        /// <param name="input"></param>
+        /// <param name="parameterName"></param>
+        /// <param name="message">Optional. Custom error message</param>
+        /// <returns><paramref name="input" /> if the value is not an empty string.</returns>
+        /// <exception cref="ArgumentException"></exception>
+        public static ReadOnlySpan<char> Empty(this IGuardClause guardClause,
+            ReadOnlySpan<char> input,
+            string parameterName,
+            string? message = null)
+        {
+            if (input.Length == 0 || input == string.Empty)
+            {
+                throw new ArgumentException(message ?? $"Required input {parameterName} was empty.", parameterName);
+            }
+            return input;
+        }
+
+        /// <summary>
+        /// Throws an <see cref="ArgumentException" /> if <paramref name="input" /> is an empty or white space string.
+        /// </summary>
+        /// <param name="guardClause"></param>
+        /// <param name="input"></param>
+        /// <param name="parameterName"></param>
+        /// <param name="message">Optional. Custom error message</param>
+        /// <returns><paramref name="input" /> if the value is not an empty or whitespace string.</returns>
+        /// <exception cref="ArgumentException"></exception>
+        public static ReadOnlySpan<char> WhiteSpace(this IGuardClause guardClause,
+            ReadOnlySpan<char> input,
+            string parameterName,
+            string? message = null)
+        {
+            if (MemoryExtensions.IsWhiteSpace(input))
+            {
+                throw new ArgumentException(message ?? $"Required input {parameterName} was empty.", parameterName);
+            }
+
+            return input;
+        }
+#endif
+    }
+}

test/GuardClauses.UnitTests/GuardAgainstNullOrEmpty.cs

@@ -12,6 +12,7 @@ public class GuardAgainstNullOrEmpty
     public void DoesNothingGivenNonEmptyStringValue()
     {
         Guard.Against.NullOrEmpty("a", "string");
+        Guard.Against.Empty("a".AsSpan(), "stringSpan");
         Guard.Against.NullOrEmpty("1", "aNumericString");
     }
 
@@ -41,6 +42,12 @@ public void ThrowsGivenEmptyString()
         Assert.Throws<ArgumentException>(() => Guard.Against.NullOrEmpty("", "emptyString"));
     }
 
+    [Fact]
+    public void ThrowsGivenEmptyStringSpan()
+    {
+        Assert.Throws<ArgumentException>(() => Guard.Against.Empty("".AsSpan(), "emptyStringSpan"));
+    }
+
     [Fact]
     public void ThrowsGivenNullGuid()
     {

test/GuardClauses.UnitTests/GuardAgainstNullOrWhiteSpace.cs

@@ -15,6 +15,7 @@ public class GuardAgainstNullOrWhiteSpace
     public void DoesNothingGivenNonEmptyStringValue(string nonEmptyString)
     {
         Guard.Against.NullOrWhiteSpace(nonEmptyString, "string");
+        Guard.Against.WhiteSpace(nonEmptyString.AsSpan(), "stringSpan");
         Guard.Against.NullOrWhiteSpace(nonEmptyString, "aNumericString");
     }
 
@@ -30,12 +31,19 @@ public void ThrowsGivenEmptyString()
         Assert.Throws<ArgumentException>(() => Guard.Against.NullOrWhiteSpace("", "emptystring"));
     }
 
+    [Fact]
+    public void ThrowsGivenEmptyStringSpan()
+    {
+        Assert.Throws<ArgumentException>(() => Guard.Against.WhiteSpace("".AsSpan(), "emptyStringSpan"));
+    }
+
     [Theory]
     [InlineData(" ")]
     [InlineData("   ")]
     public void ThrowsGivenWhiteSpaceString(string whiteSpaceString)
     {
         Assert.Throws<ArgumentException>(() => Guard.Against.NullOrWhiteSpace(whiteSpaceString, "whitespacestring"));
+        Assert.Throws<ArgumentException>(() => Guard.Against.WhiteSpace(whiteSpaceString.AsSpan(), "whiteSpaceStringSpan"));
     }
 
     [Theory]
@@ -47,6 +55,7 @@ public void ThrowsGivenWhiteSpaceString(string whiteSpaceString)
     public void ReturnsExpectedValueGivenNonEmptyStringValue(string nonEmptyString, string expected)
     {
         Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString, "string"));
+        Assert.Equal(expected, Guard.Against.WhiteSpace(nonEmptyString.AsSpan(), "stringSpan").ToString());
         Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString, "aNumericString"));
     }