FluentObjectValidator Download - FluentObjectValidator Código fonte download

FluentObjectValidator

Outras categorias

1.0.0

Baixar

FluentObjectValidator

O FluEntoBjectValidator é uma biblioteca de validação pequena e simples que fornece interface fluente para a configuração de regras.

A biblioteca visa fornecer uma alternativa à validação baseada em atributos de um modelo (requerirttribute, stringLengthattribute, etc.).

Pré -requisitos

A biblioteca tem como alvo .NET Standart 1.0, .NET 4.0, .NET 4.5

Instalação

A biblioteca está disponível como um pacote NUGET.

Começando

Aqui estão as etapas que o ajudarão a configurar a validação em seu aplicativo.

Escolha o resultado
Configure as regras
Validar

Escolha o resultado

Primeiro, você precisará decidir quais informações você gostaria de receber, quando um determinado modelo não passar na validação.

As principais classes que fornecem a funcionalidade de validação são:

Validator - Retorna um valor booleano que indica que a validação passou ou não.
Validator<TError> - Retorna uma instância do objeto ValidationResult<TError> , que contém um valor booleano e uma coleção de objetos TError personalizados que mostrarão exatamente qual das regras não passou.

Depois de decidir qual validador usar, tudo o que você precisa fazer é herdar dele e adicionar as configurações, assim:

 public class MyValidator : Validator
{
    public MyValidator ( )
    {
        AddConfiguration ( new ProductDTOConfiguration ( ) ) ;
        AddConfiguration ( new UserDTOConfiguration ( ) ) ;
    }
}

 public class MyValidator : Validator < MyCustomError >
{
    public MyValidator ( )
    {
        AddConfiguration ( new ProductDTOConfiguration ( ) ) ;
        AddConfiguration ( new UserDTOConfiguration ( ) ) ;
    }
}

Isso nos leva ao próximo passo.

Configure as regras

Para configurar as regras que seus objetos devem seguir, você precisa criar classes de configuração para cada um dos tipos que deseja validar.

Dependendo do validador escolhido, todas as configurações herdam da ValidationConfiguration<TObject> ou ValidationConfiguration<TObject, TError> .

`ValidationConfiguration<TObject>`

 public class ProductDTOConfiguration : ValidationConfiguration < ProductDTO >
{
    public ProductDTOConfiguration ( )
    {
        Property ( x => x . Title )
            . IsRequired ( )
            . HasRule ( x => x . Length <= 10 ) ;
    }
}

Depois de selecionar a propriedade, você pode adicionar as regras de validação de maneira fluente.

Você pode definir quaisquer regras com um método HasRule , mas existem vários atalhos predefinidos, como IsRequired disponível para todos os objetos e HasMinLength , HasMaxLength , HasLengthInRange , MatchesRegex disponível apenas para seqüências de caracteres.

A validação ocorre sequencialmente em uma ordem, as regras foram definidas e retorna false assim que uma das regras não passasse, ou true se todas elas passaram.

`ValidationConfiguration<TObject, TError>`

 public class ProductDTOConfiguration : ValidationConfiguration < ProductDTO , MyCustomError >
{
    public ProductDTOConfiguration ( )
    {
        Property ( x => x . Title )
            . IsRequired ( ( ) => new MyCustomError ( "Title is required" ) )
            . HasRule (
                x => x . Length <= 10 ,
                ( ) => new MyCustomError ( "Title is too long" ) ) ;
    }
}

A configuração da validação, que retorna erros personalizados em caso de falhas, é um pouco mais complexo.

Depois de selecionar uma propriedade e definir uma regra, agora você precisa adicionar um delegado que será usado para criar o objeto de erro se a regra não passar.

A validação também ocorre sequencialmente em uma ordem, as regras foram definidas, mas se uma das regras não passar, o erro será adicionado ao resultado e a validação continuar.

Você pode configurar a validação para pular o restante das regras para uma propriedade atual ou para todo o objeto, caso uma regra específica não seja aprovada. Isso pode ser feito passando os parâmetros booleanos opcionais correspondentes stopValidationOnError e terminateValidationOnError para o método HasRule . Ambos são falsos por padrão.

O método IsRequired sempre pula o restante das regras para uma propriedade, pois não precisamos verificar outras regras se a propriedade for, por exemplo, igual a NULL.

Regras de atalho como IsRequired , HasMaxLength são implementadas por métodos de extensão, para que você possa adicionar facilmente seus próprios atalhos ao seu projeto.

Validar

Depois de configurar as regras, agora você pode criar a instância do seu validador e usá -la onde quiser.

 var res = validator . Validate ( obj ) ;

Cada validador expõe um único método de 'validação' público, disponível através de interfaces:

 public interface IValidator < TError >
{
    ValidationResult < TError > Validate < TObject > ( TObject target ) ;
}
    
public interface IValidator
{
    bool Validate < TObject > ( TObject target ) ;
}

É por isso que você pode usá -lo facilmente com injeção de dependência:

 services . AddSingleton < IValidator , MyValidator > ( )

 container . Register < IValidator < MyCustomError > , MyValidator > ( Lifestyle . Singleton ) ;

Todas as configurações são carregadas e validadas durante a criação da instância do validador; portanto, na minha opinião, é melhor usá -lo como um singleton.