More extension methods organised into extension blocks. Preconditions updated to support CallerArgumentException.

Author: MrMatthewLayton

OnixLabs.Core.UnitTests/PreconditionTests.cs

@@ -332,7 +332,7 @@ public void RequireIsFailureShouldThrowAnInvalidOperationExceptionWhenTheResultI
         Exception exception = Assert.Throws<ArgumentException>(() => RequireIsFailure(result));
 
         // Then
-        Assert.Equal("Argument must be a Failure state.", exception.Message);
+        Assert.Equal("Argument must be a Failure state. (Parameter 'result')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireIsFailure should return a Failure when the result is a failure state")]
@@ -358,7 +358,7 @@ public void RequireIsSuccessShouldThrowAnInvalidOperationExceptionWhenTheResultI
         Exception exception = Assert.Throws<ArgumentException>(() => RequireIsSuccess(result));
 
         // Then
-        Assert.Equal("Argument must be a Success state.", exception.Message);
+        Assert.Equal("Argument must be a Success state. (Parameter 'result')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireIsSuccess should return a Success when the result is a success state")]
@@ -384,7 +384,7 @@ public void RequireIsFailureTShouldThrowAnInvalidOperationExceptionWhenTheResult
         Exception exception = Assert.Throws<ArgumentException>(() => RequireIsFailure(result));
 
         // Then
-        Assert.Equal("Argument must be a Failure state.", exception.Message);
+        Assert.Equal("Argument must be a Failure state. (Parameter 'result')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireIsFailure<T> should return a Failure when the result is a failure state")]
@@ -410,7 +410,7 @@ public void RequireIsSuccessTShouldThrowAnInvalidOperationExceptionWhenTheResult
         Exception exception = Assert.Throws<ArgumentException>(() => RequireIsSuccess(result));
 
         // Then
-        Assert.Equal("Argument must be a Success state.", exception.Message);
+        Assert.Equal("Argument must be a Success state. (Parameter 'result')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireIsSuccess<T> should return a Success when the result is a success state")]
@@ -436,7 +436,7 @@ public void RequireIsNoneShouldThrowAnInvalidOperationExceptionWhenTheOptionalIs
         Exception exception = Assert.Throws<ArgumentException>(() => RequireIsNone(optional));
 
         // Then
-        Assert.Equal("Argument must be a None<T> value.", exception.Message);
+        Assert.Equal("Argument must be a None<T> value. (Parameter 'optional')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireIsNone<T> should return a None<T> when the optional is a None<T> value")]
@@ -462,7 +462,7 @@ public void RequireIsSomeShouldThrowAnInvalidOperationExceptionWhenTheOptionalIs
         Exception exception = Assert.Throws<ArgumentException>(() => RequireIsSome(optional));
 
         // Then
-        Assert.Equal("Argument must be a Some<T> value.", exception.Message);
+        Assert.Equal("Argument must be a Some<T> value. (Parameter 'optional')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireIsSome<T> should return a Some<T> when the optional is a Some<T> value")]
@@ -485,7 +485,7 @@ public void RequireWithinRangeInclusiveShouldThrowArgumentOutOfRangeExceptionWhe
         Exception exception = Assert.Throws<ArgumentOutOfRangeException>(() => RequireWithinRangeInclusive(1, 2, 3));
 
         // Then
-        Assert.Equal("Argument must be within range.", exception.Message);
+        Assert.Equal("Argument must be within range. (Parameter '1')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireWithinRangeInclusive should throw an ArgumentOutOfRangeException when the value falls above the specified range")]
@@ -495,7 +495,7 @@ public void RequireWithinRangeInclusiveShouldThrowArgumentOutOfRangeExceptionWhe
         Exception exception = Assert.Throws<ArgumentOutOfRangeException>(() => RequireWithinRangeInclusive(4, 2, 3));
 
         // Then
-        Assert.Equal("Argument must be within range.", exception.Message);
+        Assert.Equal("Argument must be within range. (Parameter '4')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireWithinRangeInclusive should not throw an ArgumentOutOfRangeException when the value is exactly the minimum value")]
@@ -544,7 +544,7 @@ public void RequireWithinRangeExclusiveShouldThrowArgumentOutOfRangeExceptionWhe
         Exception exception = Assert.Throws<ArgumentOutOfRangeException>(() => RequireWithinRangeExclusive(2, 2, 4));
 
         // Then
-        Assert.Equal("Argument must be within range.", exception.Message);
+        Assert.Equal("Argument must be within range. (Parameter '2')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireWithinRangeExclusive should throw an ArgumentOutOfRangeException when the value falls above the specified range")]
@@ -554,7 +554,7 @@ public void RequireWithinRangeExclusiveShouldThrowArgumentOutOfRangeExceptionWhe
         Exception exception = Assert.Throws<ArgumentOutOfRangeException>(() => RequireWithinRangeExclusive(4, 2, 4));
 
         // Then
-        Assert.Equal("Argument must be within range.", exception.Message);
+        Assert.Equal("Argument must be within range. (Parameter '4')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireWithinRangeExclusive should not throw an ArgumentOutOfRangeException when the value falls between the specified range")]
@@ -577,7 +577,7 @@ public void RequireNotNullShouldThrowArgumentNullExceptionWhenConditionIsNull()
         Exception exception = Assert.Throws<ArgumentNullException>(() => RequireNotNull<object>(null));
 
         // Then
-        Assert.Equal("Argument must not be null.", exception.Message);
+        Assert.Equal("Argument must not be null. (Parameter 'null')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireNotNull should not throw an InvalidOperationException when the condition is not null")]
@@ -599,7 +599,7 @@ public void RequireNotNullOfValueTypeShouldThrowInvalidOperationExceptionWhenCon
 
         // Then
         Assert.Equal(0, actual);
-        Assert.Equal("Argument must not be null.", exception.Message);
+        Assert.Equal("Argument must not be null. (Parameter 'expected')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireNotNull of ValueType should not throw an InvalidOperationException when the condition is not null")]
@@ -622,7 +622,7 @@ public void RequireNotNullOrEmptyShouldThrowArgumentExceptionWhenValueIsNull()
         Exception exception = Assert.Throws<ArgumentException>(() => RequireNotNullOrEmpty(null));
 
         // Then
-        Assert.Equal("Argument must not be null or empty.", exception.Message);
+        Assert.Equal("Argument must not be null or empty. (Parameter 'null')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireNotNullOrEmpty should throw an ArgumentException when the value is empty")]
@@ -632,7 +632,7 @@ public void RequireNotNullOrEmptyShouldThrowArgumentExceptionWhenValueIsEmpty()
         Exception exception = Assert.Throws<ArgumentException>(() => RequireNotNullOrEmpty(string.Empty));
 
         // Then
-        Assert.Equal("Argument must not be null or empty.", exception.Message);
+        Assert.Equal("Argument must not be null or empty. (Parameter 'string.Empty')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireNotNullOrEmpty should return the argument value when the value is not null and not empty")]
@@ -655,7 +655,7 @@ public void RequireNotNullOrWhiteSpaceShouldThrowArgumentExceptionWhenValueIsNul
         Exception exception = Assert.Throws<ArgumentException>(() => RequireNotNullOrWhiteSpace(null));
 
         // Then
-        Assert.Equal("Argument must not be null or whitespace.", exception.Message);
+        Assert.Equal("Argument must not be null or whitespace. (Parameter 'null')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireNotNullOrWhiteSpace should throw an ArgumentException when the value is whitespace")]
@@ -665,7 +665,7 @@ public void RequireNotNullOrWhiteSpaceShouldThrowArgumentExceptionWhenValueIsWhi
         Exception exception = Assert.Throws<ArgumentException>(() => RequireNotNullOrWhiteSpace("    "));
 
         // Then
-        Assert.Equal("Argument must not be null or whitespace.", exception.Message);
+        Assert.Equal("Argument must not be null or whitespace. (Parameter '\"    \"')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireNotNullOrWhiteSpace should return the argument value when the value is not null and not whitespace")]
@@ -688,7 +688,7 @@ public void RequireIsDefinedShouldThrowArgumentOutOfRangeExceptionWhenSpecifiedE
         Exception exception = Assert.Throws<ArgumentOutOfRangeException>(() => RequireIsDefined((Shape)2));
 
         // Then
-        Assert.Equal("Invalid Shape enum value: 2. Valid values include: Square, Circle.", exception.Message);
+        Assert.Equal("Invalid Shape enum value: 2. Valid values include: Square, Circle. (Parameter '(Shape)2')", exception.Message);
     }
 
     [Fact(DisplayName = "RequireIsDefined should not throw an ArgumentOutOfRangeException when the specified enum value is defined")]

OnixLabs.Core/Collections/Generic/Extensions.IEqualityComparer.cs

@@ -18,17 +18,23 @@
 namespace OnixLabs.Core.Collections.Generic;
 
 /// <summary>
-/// Provides LINQ-like extension methods for <see cref="IEqualityComparer{T}"/>.
+/// Provides extension methods for <see cref="IEqualityComparer{T}"/> instances.
 /// </summary>
 // ReSharper disable InconsistentNaming
 [EditorBrowsable(EditorBrowsableState.Never)]
 public static class IEqualityComparerExtensions
 {
     /// <summary>
-    /// Gets the current <see cref="IEqualityComparer{T}"/>, or the default comparer if the current comparer is <see langword="null"/>.
+    /// Provides extension methods for <see cref="IEqualityComparer{T}"/> instances.
     /// </summary>
-    /// <param name="comparer">The current <see cref="IEqualityComparer{T}"/>.</param>
-    /// <typeparam name="T">The underlying type of the current <see cref="IEqualityComparer{T}"/>.</typeparam>
-    /// <returns>Returns the current <see cref="IEqualityComparer{T}"/>, or the default comparer if the current comparer is <see langword="null"/>.</returns>
-    public static IEqualityComparer<T> GetOrDefault<T>(this IEqualityComparer<T>? comparer) => comparer ?? EqualityComparer<T>.Default;
+    /// <param name="receiver">The current <see cref="IEqualityComparer{T}"/> instance.</param>
+    /// <typeparam name="T">The underlying type of the current <see cref="IEqualityComparer{T}"/> instance.</typeparam>
+    extension<T>(IEqualityComparer<T>? receiver)
+    {
+        /// <summary>
+        /// Gets the current <see cref="IEqualityComparer{T}"/>, or the default comparer if the current comparer is <see langword="null"/>.
+        /// </summary>
+        /// <returns>Returns the current <see cref="IEqualityComparer{T}"/>, or the default comparer if the current comparer is <see langword="null"/>.</returns>
+        public IEqualityComparer<T> GetOrDefault() => receiver ?? EqualityComparer<T>.Default;
+    }
 }

OnixLabs.Core/Linq/Extensions.Expression.cs

@@ -20,80 +20,82 @@
 namespace OnixLabs.Core.Linq;
 
 /// <summary>
-/// Provides extension methods for <see cref="Expression{TDelegate}"/>.
+/// Provides extension methods for <see cref="Expression{TDelegate}"/> instances.
 /// </summary>
 [EditorBrowsable(EditorBrowsableState.Never)]
 public static class ExpressionExtensions
 {
     private const string ParameterName = "$param";
 
     /// <summary>
-    /// Combines two <see cref="Expression{TDelegate}"/> instances into a single expression using the logical AND operator.
+    /// Provides extension methods for <see cref="Expression{TDelegate}"/> instances.
     /// </summary>
-    /// <param name="left">The left-hand expression to combine.</param>
-    /// <param name="right">The right-hand expression to combine.</param>
-    /// <typeparam name="T">The underlying type of the expression.</typeparam>
-    /// <returns>
-    /// Returns a new <see cref="Expression{TDelegate}"/> that combines two <see cref="Expression{TDelegate}"/> instances
-    /// into a single expression using the logical AND operator.
-    /// </returns>
-    /// <remarks>
-    /// Calling this method introduces a new expression parameter (named <c>$param</c>) to ensure both expressions share the same parameter.
-    /// Internal or nested lambda parameters that do not match the replaced parameter remain untouched.
-    /// </remarks>
-    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
+    /// <param name="receiver">The current (left-hand) <see cref="Expression{TDelegate}"/> instance.</param>
+    /// <typeparam name="T">The underlying type of the current (left-hand) <see cref="Expression{TDelegate}"/> instance.</typeparam>
+    extension<T>(Expression<Func<T, bool>> receiver)
     {
-        ParameterExpression parameter = Expression.Parameter(typeof(T), ParameterName);
-        Expression leftBody = new ReplaceParameterVisitor(left.Parameters.First(), parameter).Visit(left.Body);
-        Expression rightBody = new ReplaceParameterVisitor(right.Parameters.First(), parameter).Visit(right.Body);
-        BinaryExpression binaryExpression = Expression.AndAlso(leftBody, rightBody);
+        /// <summary>
+        /// Combines two <see cref="Expression{TDelegate}"/> instances into a single expression using the logical AND operator.
+        /// </summary>
+        /// <param name="other">The other (right-hand) expression to combine.</param>
+        /// <returns>
+        /// Returns a new <see cref="Expression{TDelegate}"/> that combines two <see cref="Expression{TDelegate}"/> instances
+        /// into a single expression using the logical AND operator.
+        /// </returns>
+        /// <remarks>
+        /// Calling this method introduces a new expression parameter (named <c>$param</c>) to ensure both expressions share the same parameter.
+        /// Internal or nested lambda parameters that do not match the replaced parameter remain untouched.
+        /// </remarks>
+        public Expression<Func<T, bool>> And(Expression<Func<T, bool>> other)
+        {
+            ParameterExpression parameter = Expression.Parameter(typeof(T), ParameterName);
+            Expression leftBody = new ReplaceParameterVisitor(receiver.Parameters.First(), parameter).Visit(receiver.Body);
+            Expression rightBody = new ReplaceParameterVisitor(other.Parameters.First(), parameter).Visit(other.Body);
+            BinaryExpression binaryExpression = Expression.AndAlso(leftBody, rightBody);
 
-        return Expression.Lambda<Func<T, bool>>(binaryExpression, parameter);
-    }
+            return Expression.Lambda<Func<T, bool>>(binaryExpression, parameter);
+        }
 
-    /// <summary>
-    /// Combines two <see cref="Expression{TDelegate}"/> instances into a single expression using the logical OR operator.
-    /// </summary>
-    /// <param name="left">The left-hand expression to combine.</param>
-    /// <param name="right">The right-hand expression to combine.</param>
-    /// <typeparam name="T">The underlying type of the expression.</typeparam>
-    /// <returns>
-    /// Returns a new <see cref="Expression{TDelegate}"/> that combines two <see cref="Expression{TDelegate}"/> instances
-    /// into a single expression using the logical OR operator.
-    /// </returns>
-    /// <remarks>
-    /// Calling this method introduces a new expression parameter (named <c>$param</c>) to ensure both expressions share the same parameter.
-    /// Internal or nested lambda parameters that do not match the replaced parameter remain untouched.
-    /// </remarks>
-    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
-    {
-        ParameterExpression parameter = Expression.Parameter(typeof(T), ParameterName);
-        Expression leftBody = new ReplaceParameterVisitor(left.Parameters.First(), parameter).Visit(left.Body);
-        Expression rightBody = new ReplaceParameterVisitor(right.Parameters.First(), parameter).Visit(right.Body);
-        BinaryExpression binaryExpression = Expression.OrElse(leftBody, rightBody);
+        /// <summary>
+        /// Combines two <see cref="Expression{TDelegate}"/> instances into a single expression using the logical OR operator.
+        /// </summary>
+        /// <param name="other">The other (right-hand) expression to combine.</param>
+        /// <returns>
+        /// Returns a new <see cref="Expression{TDelegate}"/> that combines two <see cref="Expression{TDelegate}"/> instances
+        /// into a single expression using the logical OR operator.
+        /// </returns>
+        /// <remarks>
+        /// Calling this method introduces a new expression parameter (named <c>$param</c>) to ensure both expressions share the same parameter.
+        /// Internal or nested lambda parameters that do not match the replaced parameter remain untouched.
+        /// </remarks>
+        public Expression<Func<T, bool>> Or(Expression<Func<T, bool>> other)
+        {
+            ParameterExpression parameter = Expression.Parameter(typeof(T), ParameterName);
+            Expression leftBody = new ReplaceParameterVisitor(receiver.Parameters.First(), parameter).Visit(receiver.Body);
+            Expression rightBody = new ReplaceParameterVisitor(other.Parameters.First(), parameter).Visit(other.Body);
+            BinaryExpression binaryExpression = Expression.OrElse(leftBody, rightBody);
 
-        return Expression.Lambda<Func<T, bool>>(binaryExpression, parameter);
-    }
+            return Expression.Lambda<Func<T, bool>>(binaryExpression, parameter);
+        }
 
-    /// <summary>
-    /// Negates the current <see cref="Expression{TDelegate}"/> instance using the logical NOT operator.
-    /// </summary>
-    /// <param name="expression">The expression to negate.</param>
-    /// <typeparam name="T">The underlying type of the expression.</typeparam>
-    /// <returns>
-    /// Returns a new <see cref="Expression{TDelegate}"/> that negates the current <see cref="Expression{TDelegate}"/> instance using the logical NOT operator.
-    /// </returns>
-    /// <remarks>
-    /// Calling this method introduces a new expression parameter (named <c>$param</c>) to ensure a uniform parameter expression.
-    /// Internal or nested lambda parameters that do not match the replaced parameter remain untouched.
-    /// </remarks>
-    public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expression)
-    {
-        ParameterExpression parameter = Expression.Parameter(typeof(T), ParameterName);
-        Expression expressionBody = new ReplaceParameterVisitor(expression.Parameters.First(), parameter).Visit(expression.Body);
+        /// <summary>
+        /// Negates the current <see cref="Expression{TDelegate}"/> instance using the logical NOT operator.
+        /// </summary>
+        /// <returns>
+        /// Returns a new <see cref="Expression{TDelegate}"/> that negates the current <see cref="Expression{TDelegate}"/> instance using the logical NOT operator.
+        /// </returns>
+        /// <remarks>
+        /// Calling this method introduces a new expression parameter (named <c>$param</c>) to ensure a uniform parameter expression.
+        /// Internal or nested lambda parameters that do not match the replaced parameter remain untouched.
+        /// </remarks>
+        public Expression<Func<T, bool>> Not()
+        {
+            ParameterExpression parameter = Expression.Parameter(typeof(T), ParameterName);
+            Expression expressionBody = new ReplaceParameterVisitor(receiver.Parameters.First(), parameter).Visit(receiver.Body);
 
-        UnaryExpression unaryExpression = Expression.Not(expressionBody);
-        return Expression.Lambda<Func<T, bool>>(unaryExpression, parameter);
+            UnaryExpression unaryExpression = Expression.Not(expressionBody);
+            return Expression.Lambda<Func<T, bool>>(unaryExpression, parameter);
+        }
     }
 
     /// <summary>