Valitators

In most of scenarios, you might not want to create new instance of IValitRules<TObject> for each new object. It’s better to have one class responsible for handling the validation for the particular type. Using other words, it’s better to have a valitator ;) Valit offers three ways of creating a valitators for a particular type:

• Transforming IValitRules<TObject> object using CreateValitator() method.
• Transforming IValitRulesProvider<TObject> object using CreateValitator() method.
• Creating class which implements IValitator<TObject> interface

IValitator<TObject> object provides Validate() method which accepts two arguments:

• TObject @object - object of the particular type for validation
• IValitStrategy strategy - strategy for validation process. If this argument is not given, Complete strategy is picked as a default.

Let’s say we’d like to create a valitator for the following type:

public class RegisterModel
{
    public string Email { get; set; }
    public string Password { get; set; }
    public ushort Age { get; set ;}
}

Below you can find three mentioned ways of doing that.

Creating valitator from rules

class RegistrationService
{
    private readonly IValitator<RegisterModel> _registerModelValitator;

    public RegistrationService()
    {
        _registerModelValitator = CreateValitator();
    }

    public bool Register(RegisterModel model)
    {
        var result = _registerModelValitator.Validate(model);

        if(!result.Succeeded)
        {
            return false;
        }
        ...
    }

    private IValitator<RegisterModel> CreateValitator()
        => ValitRules<RegisterModel>
            .Create()
            .Ensure(m => m.Email, _=>_
                    .Required()
                    .Email())
            .Ensure(m => m.Password, _=>_
                    .Required()
                    .MinLength(10))
            .Ensure(m => m.Age, _=>_
                    .IsGreaterThan(16))
            .CreateValitator();
}

Creating valitator class

class RegistrationService
{
    private readonly IValitator<RegisterModel> _registerModelValitator;

    public RegistrationService()
    {
        _registerModelValitator = new RegisterModelValitator();
    }

    public bool Register(RegisterModel model)
    {
        var result = _registerModelValitator.Validate(model);

        if(!result.Succeeded)
        {
            return false;
        }
        ...
    }
}

class RegisterModelValitator : IValitator<RegisterModel>
{
    private readonly IValitRulesStrategyPicker<TObject> _strategyPicker;

    public RegisterModelValitator()
    {
        var rules = GetValidationRules();
        _strategyPicker = ValitRules<RegisterModel>.Create(rules);
    }

    public IValitResult Validate(RegisterModel @object, IValitStrategy strategy)
    {
        var selectedStrategy = strategy ?? new CompleteValitStrategy();

        return _strategyPicker
            .WithStrategy(selectedStrategy)
            .For(@object)
            .Validate();
    }

    private IValitRulesStrategyPicker<RegisterModel> GetValidationRules()
        => ValitRules<RegisterModel>
            .Create()
            .Ensure(m => m.Email, _=>_
                .Required()
                .Email())
            .Ensure(m => m.Password, _=>_
                .Required()
                .MinLength(10))
            .Ensure(m => m.Age, _=>_
                .IsGreaterThan(16))
            .GetAllRules();
}