C# 14 Extension Blocks: Implementing the | Operator for Fluent Validation

public void ProcessOrder(Order order, int quantity, string customerId)
{
    if (order == null)
        throw new ArgumentNullException(nameof(order));

    if (quantity <= 0)
        throw new ArgumentException("Quantity must be positive", nameof(quantity));

    if (quantity > 1000)
        throw new ArgumentException("Quantity cannot exceed 1000", nameof(quantity));

    if (string.IsNullOrWhiteSpace(customerId))
        throw new ArgumentException("Customer ID is required", nameof(customerId));

    // Finally, the business logic...
}

public void ProcessOrder(Order order, int quantity, string customerId)
{
    var validOrder = order | (o => o != null);
    var validQty = quantity | (q => q > 0) | (q => q <= 1000);
    var validId = customerId | (s => !string.IsNullOrWhiteSpace(s));

    // The business logic, right away
}

▸ Extension Blocks: a revolution for C#

public static class StringExtensions
{
    public static bool IsNotEmpty(this string s) => !string.IsNullOrEmpty(s);
}

public static class MyExtensions
{
    extension<T>(T source)
    {
        public static T operator |(T left, Func<T, bool> predicate)
        {
            // Our logic here
        }
    }
}

▸ PipeExceptionOperations: the heart of the library

public static class PipeExceptionOperations
{
    extension<T>(T source)
    {
        /// <summary>
        /// Pipe operator for validation. Returns ValidationResult for deferred exception selection.
        /// </summary>
        public static ValidationResult<T> operator |(T left, Func<T, bool> predicate)
        {
            return new ValidationResult<T>(left, predicate, null, null);
        }

        /// <summary>
        /// Pipe operator with custom message.
        /// </summary>
        public static ValidationResult<T> operator |(T left, (Func<T, bool> predicate, string message) validation)
        {
            return new ValidationResult<T>(left, validation.predicate, validation.message, null);
        }

        /// <summary>
        /// Validates that the condition is met, throwing ArgumentException if not.
        /// </summary>
        public T Ensure(
            Func<T, bool> predicate,
            string? message = null,
            [CallerArgumentExpression(nameof(predicate))] string? predicateExpression = null)
        {
            if (!predicate(source))
            {
                var errorMessage = message ?? $"Condition not met: {predicateExpression}";
                throw new ArgumentException(errorMessage);
            }
            return source;
        }
    }
}

1. extension<T>(T source)

2. The overloaded | operator

3. The tuple overload

4. The Ensure method

▸ ValidationResult: the functional pattern

public readonly struct ValidationResult<T>
{
    private readonly T _value;
    private readonly Func<T, bool> _predicate;
    private readonly string? _message;

    // Enables chaining: result | (x => x < 100)
    public static ValidationResult<T> operator |(ValidationResult<T> result, Func<T, bool> predicate)
    {
        T value = result;  // Validate the previous predicate first
        return new ValidationResult<T>(value, predicate, null, null);
    }

    // Implicit conversion to T: this is where the exception is thrown
    public static implicit operator T(ValidationResult<T> result)
    {
        if (!result._predicate(result._value))
        {
            var errorMessage = result._message ?? $"Condition not met: {result._predicateExpression}";
            throw new ArgumentException(errorMessage);
        }
        return result._value;
    }

    // Pick the exception type
    public T OrThrowNull(string? paramName = null)
    {
        if (!_predicate(_value))
            throw new ArgumentNullException(paramName, _message);
        return _value;
    }

    public T OrThrowInvalidOperation()
    {
        if (!_predicate(_value))
            throw new InvalidOperationException(_message);
        return _value;
    }

    public T OrThrow<TException>(Func<string, TException> exceptionFactory)
        where TException : Exception
    {
        if (!_predicate(_value))
            throw exceptionFactory(_message ?? "Validation failed");
        return _value;
    }
}

Validation is deferred until you actually need the value
The implicit conversion to T triggers the validation
The OrThrow* methods let you pick the exception type
The | operator on ValidationResult enables chaining

▸ Practical examples

int age = userInput | (x => x >= 0);
// Throws ArgumentException if negative

int score = value
  | (x => x >= 0)      // Must be positive or zero
  | (x => x <= 100)    // Maximum 100
  | (x => x % 5 == 0); // Multiple of 5

int age = input | (x => x >= 18, "You must be of age to continue");

// ArgumentNullException
var user = GetUser() | (u => u != null);
user.OrThrowNull(nameof(user));

// InvalidOperationException
var config = LoadConfig() | (c => c.IsValid);
config.OrThrowInvalidOperation();

// Custom exception
var data = FetchData() | (d => d.Count > 0);
data.OrThrow(msg => new DataNotFoundException(msg));

// Numeric
int positive = value | Validate.Positive;
int nonNeg = value | Validate.NonNegative;
int ranged = value | Validate.InRange(1, 100);

// Strings
string name = input | Validate.NotNullOrEmpty;
string text = input | Validate.NotNullOrWhiteSpace;

// Collections
var items = list | Validate.NotEmpty<int>();
var sized = list | Validate.HasMinCount<int>(5);

▸ Specialized extensions included

string validated = input
  .EnsureNotNullOrEmpty()
  .EnsureMinLength(3)
  .EnsureMaxLength(50);

var items = list
  .EnsureNotEmpty()
  .EnsureMinCount(1)
  .EnsureMaxCount(100);

int value = nullableInt.EnsureNotNull("The value is required");
User user = nullableUser.EnsureNotNull(nameof(user), "User not found");

▸ Why PipeException?

Readability: the validation code reads left to right, like a sentence
Chainability: combine several validations in a single expression
Flexibility: choose the exception type after validation
Automatic messages: CallerArgumentExpression generates meaningful messages
Type-safe: everything is checked at compile time

▸ Try it!

Requirements: .NET 10 (extension blocks are a C# 14 feature)
Install: dotnet add package PipeException
The repo: github.com/phmatray/PipeException
NuGet: nuget.org/packages/PipeException