Swallow.Validation 0.5.2

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.

Keep in mind that Swallow.Validation is in a rather early stage. As long as the version is 0.x.y, it is not particularily "production-ready", as the validation might change... a lot. It should work out the way it is now, but there are no guarantees that you won't have to adjust stuff over and over when updating, especially when it's a minor version bump. Patches should be fine.

Example

You can take a look at the test suite for examples. But in general, a validation is executed as follows:

var validationResult = Validation.Check()
    .That(() => someValue).Satisfies(v => v.IsFoo(), "be foo").When(v => v.IsBar(), "bar is quuz")
    .That(() => someClass.SomeMember).IsNotNull()
    .Then(() => true);

if (validationResult.Errors.Any())
{
    Console.WriteLine("Oops, something did not validate!");
    foreach (var error in validationResult.Errors)
    {
        Console.WriteLine(error.ToString());
    }
}

This will produce the following output, given that v.IsBar() returns true, v.IsFoo() returns false, someClass.SomeMember is null and someValue.ToString() returns "someValue":

Oops, something did not validate!
someValue must be foo when bar is quuz but was 'someValue'
someClass.SomeMember must not be null

Custom errors

To make errors presentable to a user (for example by translating the technical english to the UI language), Swallow.Validation supports custom error types containing information not as a string, but as typed fields.

There are a bunch of predefined custom errors, such as EmptyCollectionValidationError, RegexValidationError and RangeValidationError. You can define your own errors, too! Create your class, inherit from ValidationError and you're good to go. The property name and actual value will be filled in automatically, no need to take them in a constructor and assign them.

It also is a good idea to have your custom error override ToString(), to allow the error to be written as log message or simply be viewed nicely while debugging.

Custom validation rules

Always specifying a predicate and error message by calling Satisfies is not very DRY and prone to typos and differences. To help just that, there are a bunch of extensions like IsInRange or Matches that check predefined predicates on assertions and produce certain custom errors. Swallow.Validation comes with a basic set of these out-of-the-box, but you can (and should, probably!) add your own extensions to fill the gaps in your domain. Write an extension taking IAssertable<T> as this and returning IConditionable<TYourError> to have a fancy extension! As an example:

public static class FooExtensions
{
    public static IConditionable<FooError> IsAFoo<T>(this IAssertable<T> assertion)
    {
        return assertion.Satisfies(x => x is Foo, _ => new FooError());
    }
}

Whoa, where you got that fancy badge from?

Check out Buildstats for fancy badges like this one.