La validación de datos es uno de los pilares fundamentales en cualquier aplicación robusta. En .NET Core, tenemos dos enfoques principales que han demostrado ser efectivos: Data Annotations y FluentValidation. Después de trabajar con ambos durante varios proyectos, he querido compartir mis experiencias y recomendaciones.

🏗️ ¿Por qué es crucial la validación?

Antes de sumergirnos en las herramientas, recordemos por qué la validación es tan importante:

Integridad de datos: Garantiza que solo información válida llegue a nuestra base de datos
Seguridad: Previene ataques como inyección SQL y XSS
Experiencia de usuario: Proporciona feedback inmediato y claro
Mantenibilidad: Centraliza las reglas de negocio en un lugar específico

📋 Data Annotations: El enfoque tradicional

Data Annotations es el sistema de validación integrado en .NET Core. Utiliza atributos decoradores que se aplican directamente a las propiedades del modelo.

Ventajas principales

Simplicidad: Es increíblemente fácil de implementar. Con solo agregar atributos a las propiedades, tenemos validación básica funcionando.

public class Usuario
{
    [Required(ErrorMessage = "El nombre es obligatorio")]
    [StringLength(50, ErrorMessage = "El nombre no puede exceder 50 caracteres")]
    public string Nombre { get; set; }

    [Required]
    [EmailAddress(ErrorMessage = "Formato de email inválido")]
    public string Email { get; set; }

    [Range(18, 120, ErrorMessage = "La edad debe estar entre 18 y 120 años")]
    public int Edad { get; set; }
}

Integración nativa: Funciona sin configuración adicional con ASP.NET Core MVC y Web API.

Limitaciones que encontré

Después de usar Data Annotations en varios proyectos, he notado algunas limitaciones:

Validaciones complejas: Cuando necesitas validar contra la base de datos o hacer validaciones condicionales, se vuelve complicado
Reutilización: Es difícil reutilizar lógica de validación entre diferentes modelos
Testeo: Probar validaciones específicas puede ser engorroso

🚀 FluentValidation: Flexibilidad y potencia

FluentValidation es una librería externa que ofrece un enfoque más fluido y expresivo para la validación.

Instalación

dotnet add package FluentValidation
dotnet add package FluentValidation.DependencyInjectionExtensions

Implementación básica

public class UsuarioValidator : AbstractValidator<Usuario>
{
    public UsuarioValidator()
    {
        RuleFor(x => x.Nombre)
            .NotEmpty().WithMessage("El nombre es obligatorio")
            .Length(2, 50).WithMessage("El nombre debe tener entre 2 y 50 caracteres");

        RuleFor(x => x.Email)
            .NotEmpty().WithMessage("El email es obligatorio")
            .EmailAddress().WithMessage("Formato de email inválido");

        RuleFor(x => x.Edad)
            .InclusiveBetween(18, 120).WithMessage("La edad debe estar entre 18 y 120 años");
    }
}

Configuración en Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddFluentValidationAutoValidation();
    services.AddValidatorsFromAssemblyContaining<UsuarioValidator>();
    // otros servicios...
}

⚖️ Comparación práctica

Escenario 1: Validación simple

Para validaciones básicas como campos requeridos, longitudes y formatos, Data Annotations es más directo:

// Data Annotations - Más conciso
[Required, StringLength(50)]
public string Nombre { get; set; }

// FluentValidation - Más verboso
RuleFor(x => x.Nombre)
    .NotEmpty()
    .Length(1, 50);

Escenario 2: Validaciones complejas

Para lógica compleja, FluentValidation brilla:

public class PedidoValidator : AbstractValidator<Pedido>
{
    public PedidoValidator(IProductoService productoService)
    {
        RuleFor(x => x.ProductoId)
            .MustAsync(async (id, cancellation) => 
                await productoService.ExisteAsync(id))
            .WithMessage("El producto no existe");

        RuleFor(x => x.Cantidad)
            .GreaterThan(0)
            .When(x => x.Tipo == TipoPedido.Compra);

        RuleFor(x => x.FechaEntrega)
            .Must(fecha => fecha > DateTime.Now.AddDays(1))
            .WithMessage("La fecha de entrega debe ser al menos mañana");
    }
}

🛠️ Casos de uso recomendados

Usa Data Annotations cuando:

✅ Tienes validaciones simples y directas
✅ Trabajas con un equipo pequeño
✅ El proyecto es relativamente simple
✅ Prefieres mantener menos dependencias

Usa FluentValidation cuando:

✅ Necesitas validaciones complejas o condicionales
✅ Requieres validación asíncrona
✅ Trabajas en un proyecto empresarial grande
✅ Quieres mejor testabilidad
✅ Necesitas reutilizar lógica de validación

🎯 Mejores prácticas

Para Data Annotations:

public class Producto
{
    [Required(ErrorMessage = "El nombre es obligatorio")]
    [Display(Name = "Nombre del producto")]
    public string Nombre { get; set; }

    [Range(0.01, double.MaxValue, ErrorMessage = "El precio debe ser mayor a 0")]
    [DataType(DataType.Currency)]
    public decimal Precio { get; set; }
}

Para FluentValidation:

public class ProductoValidator : AbstractValidator<Producto>
{
    public ProductoValidator()
    {
        RuleFor(x => x.Nombre)
            .NotEmpty().WithMessage("El nombre es obligatorio")
            .Must(BeUniqueName).WithMessage("Ya existe un producto con este nombre");

        RuleFor(x => x.Precio)
            .GreaterThan(0).WithMessage("El precio debe ser mayor a 0")
            .ScalePrecision(2, 10).WithMessage("El precio no puede tener más de 2 decimales");
    }

    private bool BeUniqueName(string nombre)
    {
        // Lógica para verificar unicidad
        return true;
    }
}

📊 Rendimiento y consideraciones

En mis pruebas, Data Annotations tiene un overhead ligeramente menor para validaciones simples, mientras que FluentValidation puede ser más eficiente para validaciones complejas gracias a su sistema de compilación de expresiones.

🎉 Conclusión

La elección entre Data Annotations y FluentValidation no es binaria. En proyectos grandes, he usado ambos: Data Annotations para validaciones simples y FluentValidation para lógica compleja.

Mi recomendación personal:

Proyectos pequeños a medianos: Data Annotations
Aplicaciones empresariales: FluentValidation
Proyectos híbridos: Una combinación de ambos

La validación efectiva no solo se trata de la herramienta que elijas, sino de cómo la implementes consistentemente en tu arquitectura. Cualquiera que sea tu elección, asegúrate de que todo el equipo esté alineado con el enfoque.

Validación de modelos en .NET Core: Data Annotations vs FluentValidation