Fluent API

Chain multiple validations together using Validixty's fluent interface for complex validation scenarios.

What is Fluent API?

The Fluent API in Validixty allows you to chain multiple validation operations together in a readable, expressive way. This is perfect for validating complex objects with multiple fields or when you need to perform sequential validations with conditional logic.

Why Use Fluent API?

• Readability: Chain operations in a natural, readable flow
• Complex Validation: Handle multi-field validation scenarios
• Conditional Logic: Apply validations based on previous results
• Comprehensive Results: Get detailed validation results for all fields

Before Using Validixty

Without Validixty, complex validation might look like this:

using System.ComponentModel.DataAnnotations;

public class UserRegistration
{
    public string Email { get; set; }
    public string Phone { get; set; }
    public string Password { get; set; }
    public string ConfirmPassword { get; set; }
}

public ValidationResult ValidateUser(UserRegistration user)
{
    var errors = new List();

    // Email validation
    if (string.IsNullOrEmpty(user.Email))
        errors.Add("Email is required");
    else if (!Regex.IsMatch(user.Email, "^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$"))
        errors.Add("Invalid email format");

    // Phone validation
    if (string.IsNullOrEmpty(user.Phone))
        errors.Add("Phone is required");
    else if (!Regex.IsMatch(user.Phone, "^(\\+20|0)?1[0-2,5]\\d{8}$"))
        errors.Add("Invalid Egyptian phone number");

    // Password validation
    if (string.IsNullOrEmpty(user.Password))
        errors.Add("Password is required");
    else if (user.Password.Length < 8)
        errors.Add("Password must be at least 8 characters");
    else if (!Regex.IsMatch(user.Password, "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).+$"))
        errors.Add("Password must contain uppercase, lowercase, and number");

    // Confirm password
    if (user.Password != user.ConfirmPassword)
        errors.Add("Passwords do not match");

    return errors.Any() ? new ValidationResult(false, string.Join("; ", errors))
                       : new ValidationResult(true, "Valid");
}

After Using Validixty

With Validixty's Fluent API, the same validation becomes much cleaner:

using Validixty.Core;

public ValidationResult ValidateUser(UserRegistration user)
{
    return Validation.For("User Registration")
        .CheckEmail(user.Email)
        .CheckPhone(x => x.Country == CountriesEnum.Egypt, user.Phone)
        .CheckPassword(user.Password)
        .Check(x => x.Password == x.ConfirmPassword, "Passwords do not match")
        .Validate();
}

How It Saves Time

• Eliminates boilerplate: No need to write repetitive validation code
• Reduces complexity: Complex validations become simple chains
• Improves maintainability: Easy to modify and extend validations
• Better error handling: Comprehensive validation results

Usage Examples

User Registration Validation

var result = Validation.For("User Registration")
    .CheckName(user.FirstName, "First Name")
    .CheckName(user.LastName, "Last Name")
    .CheckEmail(user.Email)
    .CheckPhone(x => x.Country == CountriesEnum.Egypt, user.Phone)
    .CheckPassword(user.Password)
    .Check(x => x.Password == x.ConfirmPassword, "Passwords do not match")
    .Validate();

if (!result.IsValid)
{
    foreach (var error in result.Errors)
    {
        Console.WriteLine($"{error.FieldName}: {error.Message}");
    }
}

Payment Processing Validation

var paymentResult = Validation.For("Payment")
    .CheckCreditCard(payment.CardNumber)
    .Check(x => x.Amount > 0, "Amount must be greater than zero")
    .Check(x => x.Currency.Length == 3, "Invalid currency code")
    .CheckIBAN(payment.BankAccount)
    .Validate();

Address Validation Chain

var addressResult = Validation.For("Address")
    .Check(x => !string.IsNullOrEmpty(x.Street), "Street is required")
    .Check(x => !string.IsNullOrEmpty(x.City), "City is required")
    .CheckPostalCode(x => x.Country == CountriesEnum.Egypt, address.PostalCode)
    .Check(x => x.Coordinates != null, "Coordinates are required")
    .Validate();

Conditional Validation

var businessResult = Validation.For("Business Registration")
    .CheckName(business.Name)
    .CheckEmail(business.Email)
    .When(x => x.IsInternational,
          chain => chain.CheckIBAN(business.BankAccount))
    .When(x => !x.IsInternational,
          chain => chain.CheckBankAccount(business.BankAccount))
    .Validate();

Custom Validation Rules

var customResult = Validation.For("Custom Object")
    .Check(x => IsValidBusinessHours(x.Time), "Invalid business hours")
    .Check(x => x.Quantity >= 0 && x.Quantity <= 100, "Quantity must be between 0 and 100")
    .Check(x => x.TotalPrice == x.UnitPrice * x.Quantity, "Price calculation error")
    .Validate();