Como exemplo vou usar o FluentValidation em uma página de registro de usuário em uma aplicação Xamarin Forms.

Recursos Usados

• Visual Studio 2017 Community
• Xamarin

Criando o projeto no VS 2017

Abra o  VS 2017 Community e clique em New Project e a seguir escolha Cross Platform -> Mobile App (Xamarin.Forms) e informe o nome XF_FluentValidation:

A seguir selecione a Plataforma, eu marquei somente Android, e escolha a estratégia de compartilhamento que será .NET Standard.

Clique no botão OK.

Pronto nosso projeto já esta criado. ( Atualmente(11/2018) a versão mais atual estável é a 3.4.0)

Instalando a biblioteca FluentValidation

Vamos instalar a biblioteca FluentValidation em todos os projetos usando a opção Manage Nuget Package for Solution do menu Tools:

Criando o modelo de domínio

Vamos criar uma pasta chamada Models (Project->New Folder) no projeto .NET Standard e nesta pasta vamos criar a classe Usuario que será o nosso modelo de domínio.

Definindo a página de registro

Vamos definir a página MainPage.xaml como a nossa página que será usada como formulário de registro.

Abra o arquivo MainPage.xaml e inclua o código abaixo:

Definimos o formulário de registro com 5 views Entry e uma view Button e estamos fazendo o binding com as propriedades da nossa classe de domínio Usuario.

Aplicando as regras de validação

Agora crie uma classe chamada UsuarioValidator na pasta Models com o seguinte código:

No código acima estamos herando a classe AbstractValidator<T> com o tipo Usuario da FluentValidation e definindo as seguintes regras de validação:

• NomeUsuario: Não deverá ser vazia nem null e o tamanho do nome deve estar entre 8 e 20 caracteres;
• Telefone : Não deverá ser vazia nem null e o tamanho mínimo deve ser de no mínimo 10 caracteres;
• Email: Não deve ser null e deve ter o formato de um email;
• Senha: Não deve ser null e o tamanho deve ser de 8 caracteres;
• ConfirmaSenha: Não deve ser null e a string deve ter um tamanho igual ao valor da senha;

Criando a ViewModel

Agora crie uma pasta chamada ViewModels no projeto .NET Standard e nesta pasta crie a classe UsuarioRegistroViewModel que será a nossa view model.

using FluentValidation;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Input;
using Xamarin.Forms;
using XF_FluentValidation.Models;

namespace XF_FluentValidation.ViewModels
{
    public class UsuarioRegistroViewModel : INotifyPropertyChanged
    {
        public ICommand RegistroCommand { get; set; }
        readonly IValidator _validator;

        public UsuarioRegistroViewModel()
        {
            _validator = new UsuarioValidator();
            RegisterCommand = new Command(RegistroValidation);
        }

        void RegistroValidation()
        {
            var oUsuario = new Usuario
            {
                NomeUsuario = NomeUsuario,
                Telefone = Telefone,
                Email = Email,
                Senha = Senha,
                ConfirmaSenha = ConfirmaSenha,
            };
            var resultadoValidacoes = _validator.Validate(oUsuario);

            if (resultadoValidacoes.IsValid)
            {
                App.Current.MainPage.DisplayAlert("FluentValidation", "Validação feita com Sucesso..!!", "Ok");
            }
            else
            {
                App.Current.MainPage.DisplayAlert("FluentValidation", resultadoValidacoes.Errors[0].ErrorMessage, "Ok");
            }
        }

        string _nomeUsuario;
        public string NomeUsuario
        {
            get { return _nomeUsuario; }
            set { SetProperty(ref _nomeUsuario, value); }
        }

        string _telefone;
        public string Telefone
        {
            get { return _telefone; }
            set { SetProperty(ref _telefone, value); }
        }

        string _email;
        public string Email
        {
            get { return _email; }
            set { SetProperty(ref _email, value); }
        }

        string _senha;
        public string Senha
        {
            get { return _senha; }
            set { SetProperty(ref _senha, value); }
        }

        string _confirmaSenha;
        public string ConfirmaSenha
        {
            get { return _confirmaSenha; }
            set { SetProperty(ref _confirmaSenha, value); }
        }

        protected bool SetProperty<T>(ref T backingStore, T value,[CallerMemberName]string propertyName = "",
Action onChanged = null)
        {
            if (EqualityComparer<T>.Default.Equals(backingStore, value))
                return false;

            backingStore = value;
            onChanged?.Invoke();
            OnPropertyChanged(propertyName);
            return true;
        }

        #region INotifyPropertyChanged    
        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged([CallerMemberName] string propertyName = "")
        {
            var changed = PropertyChanged;
            if (changed == null)
                return;

            changed.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        #endregion
    }
}

É na view model que tudo acontece...

Nossa view model implementa a interface INotifyPropertyChanged e define as propriedades e o comando para o Button - Registrar - da View MainPage.xaml.

No construtor da view mode criamos um objeto para IValidator o qual define um validador para o nosso tipo Usuario e a seguir criamos um objeto Usuario e definimos os valores informados na View passando-os para o método Validate onde fazemos a validação dos dados conforme as regras definidas.

Quando o usuário preenche os campos do formulário e clica no botão Registrar o formulário será enviado e vamos invocar o método RegistroValidation por isso criamos uma propriedade ICommand que invocará o método.

Para que tudo isso funcione precisamos definir o BindingContext no arquivo MainPage.xaml.cs para receber uma instância da nossa View Model conforme mostrado a seguir:

Agora é só testar...

Pegue o código do projeto .NET Standard aqui :  XF_FluentValidation.zip (sem as referências)

"Porque Deus não nos deu o espírito de temor, mas de fortaleza, e de amor, e de moderação."
2 Timóteo 1:7