C# 14 Extension Blocks : Implémenter l'opérateur | pour des validations fluides

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));

    // Enfin, le code métier...
}

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));

    // Le code métier, directement
}

▸ Les Extension Blocks : une révolution pour 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)
        {
            // Notre logique ici
        }
    }
}

▸ PipeExceptionOperations : le cœur de la librairie

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. L'opérateur | surchargé

3. La surcharge avec tuple

4. La méthode Ensure

▸ ValidationResult : le pattern fonctionnel

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

    // Permet le chaînage : result | (x => x < 100)
    public static ValidationResult<T> operator |(ValidationResult<T> result, Func<T, bool> predicate)
    {
        T value = result;  // Valide d'abord le prédicat précédent
        return new ValidationResult<T>(value, predicate, null, null);
    }

    // Conversion implicite vers T : c'est ici que l'exception est levée
    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;
    }

    // Choisir le type d'exception
    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;
    }
}

La validation est différée jusqu'à ce qu'on ait besoin de la valeur
La conversion implicite vers T déclenche la validation
Les méthodes OrThrow* permettent de choisir le type d'exception
L'opérateur | sur ValidationResult permet le chaînage

▸ Exemples pratiques

int age = userInput | (x => x >= 0);
// Lance ArgumentException si négatif

int score = value
  | (x => x >= 0)      // Doit être positif ou zéro
  | (x => x <= 100)    // Maximum 100
  | (x => x % 5 == 0); // Multiple de 5

int age = input | (x => x >= 18, "Vous devez être majeur pour continuer");

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

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

// Exception personnalisée
var data = FetchData() | (d => d.Count > 0);
data.OrThrow(msg => new DataNotFoundException(msg));

// Numériques
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);

▸ Extensions spécialisées incluses

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

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

int value = nullableInt.EnsureNotNull("La valeur est requise");
User user = nullableUser.EnsureNotNull(nameof(user), "Utilisateur non trouvé");

▸ Pourquoi PipeException ?

Lisibilité : le code de validation se lit de gauche à droite, comme une phrase
Chaînabilité : combinez plusieurs validations en une seule expression
Flexibilité : choisissez le type d'exception après la validation
Messages automatiques : CallerArgumentExpression génère des messages significatifs
Type-safe : tout est vérifié à la compilation

▸ Essayez-le !

Prérequis : .NET 10 (les extension blocks sont une fonctionnalité C# 14)
Installation : dotnet add package PipeException
Le repo : github.com/phmatray/PipeException
NuGet : nuget.org/packages/PipeException