Swallow.Validation 0.5.3

Swallow.Validation

A lightweight, fluent-style validation library for C#. But what does that mean? That means minimal dependencies (none, actually) and great programmer experience. If you've seen Fluent Assertions, you might find some similarities.

Getting started

Validating values

A validation is created using Validator.Check(). To then actually validate a value, call That() on the validator followed by Satisfies():

Validator.Check()
    .That(() => myValue).Satisfies(x => x > 1, "be larger than 1")

You can chain another validation rule directly after the Satisfies the same as before:

Validator.Check()
    .That(() => myValue).Satisfies(x => x > 1, "be larger than 1")
    .That(() => myName).Satisfies(s => s != null, "not be null")

See that nice string? It determines what the validation error will say if the predicate is not met - if myName is null, a validation error saying "myName must not be null" will be produced. The name of the value is automatically determined, but you can of course pass it yourself, too!

Validator.Check()
    .That(() => myValue, "ThatValue").Satisfies(x => x > 1, "be larger than 1")
    .That(() => myName, "ThatName").Satisfies(s => s != null, "not be null")

To actually retrieve the validation errors - or a positive result - you can use Then().

var result = Validator.Check()
    .That(() => myValue, "ThatValue").Satisfies(x => x > 1, "be larger than 1")
    .That(() => myName, "ThatName").Satisfies(s => s != null, "not be null")
    .Then(() => new MyFancyClass(myValue, myName));

The function is executed only when there are no validation errors. What you get is a ValidationResult<MyFancyClass> where you can check the status with IsSuccess, get a list of all errors with Errors or the created value with Value.

If you don't need a result and only want to handle errors, you can similarily use Else():

Validator.Check()
    .That(() => myValue, "ThatValue").Satisfies(x => x > 1, "be larger than 1")
    .That(() => myName, "ThatName").Satisfies(s => s != null, "not be null")
    .Else(errs => throw new Exception($"{errs.Count} validation errors happened!"));

Conditional validation

If you have a validation rule that should only be checked on certain conditions, you can add a When()-call after the Satisfies() to specify when to validate and when to skip.

Validator.Check()
    .That(() => myName).Satisfies(s => s != null, "not be null")
    .That(() => myName).Satisfies(s => s.Length > 1, "not be empty").When(() => myName != null)

This way, s.Length > 1 is only executed iff myName is not null - no NullReferenceException here.

Custom validation errors

Passing a string to Satisfies() is a simple way to control the resulting validation error, but why stop there?

class IsNullError : ValidationError
{
    public override string ToString() => $"{PropertyName} is null when it's not supposed to!";
}

...

Validator.Check()
    .That(() => myName).Satisfies(s => s != null, _ => new IsNullError())

Named assertions

Using Satisfies() over and over again and specifying the very same predicate and error all over the place is not very DRY, so you can instead provide extension methods to give these assertions memorable names:

public static class MyAssertions
{
    public static IConditionable<IsNullError> IsNotNull<T>(this IAssertable<T> property)
    {
        return property.Satisfies(x => x != null, _ => new IsNullError());
    }
}

...

Validator.Check()
    .That(() => myName).IsNotNull()

Single-call assertions

If you do not like having to call two or three methods for a single validation, you can instead put everything into a combined That()-call:

Validator.Check()
    .That(() => myName, a => a.IsNotNull(a))
    .That(() => myValue, x => x > 1, () => myName != null)

This will simply expand to:

Validator.Check()
    .That(() => myName).IsNotNull()
    .That(() => myValue).Satisfies(x => x > 1, "satisfy predicate").When() => myName != null)

Going deeper

If you wish to know more about the validations and what you can do with them, I suggest you just find out by digging through the code or just using the library to build some validations.

And if you feel like something is missing (or just plain broken), feel free to create an issue.