ValidationAttribute: Validaciones Personalizadas en ASP.NET MVC

La validación de datos es un aspecto esencial en cualquier aplicación web, ya que garantiza que la información ingresada por los usuarios sea correcta y segura antes de ser procesada. En ASP.NET MVC, la validación se realiza normalmente mediante Data Annotations, que permiten definir reglas de validación directamente en los modelos de datos.  Sin embargo, a veces se requieren validaciones más específicas que las ofrecidas por las anotaciones estándar. Para estos casos, se puede crear validaciones personalizadas usando la clase ValidationAttribute.

 

Introducción

Si bien ASP.NET MVC ofrece un conjunto de validaciones estándar como [Required], [StringLength] y [Range], a veces se requieren validaciones más específicas que estas no cubren. Para tales casos, la creación de validaciones personalizadas utilizando la clase ValidationAttribute ofrece una solución potente y flexible.

Este artículo se enfocará exclusivamente en cómo implementar validaciones personalizadas en el servidor utilizando ValidationAttribute. Veremos cómo crear y aplicar atributos de validación personalizados, con un ejemplo práctico usando ASP.NET MVC.

 

 

¿Qué es ValidationAttribute?

ValidationAttribute es una clase base en el espacio de nombres System.ComponentModel.DataAnnotations que permite definir reglas de validación personalizadas. Al heredar de esta clase, se pueden crear atributos de validación que encapsulan la lógica específica necesaria para validar datos según los requerimientos de la aplicación.

Ventajas de ValidationAttribute:

• Reutilización: Los atributos personalizados pueden aplicarse a múltiples propiedades y modelos, facilitando la reutilización y mantenimiento del código.
• Integración Nativa con ASP.NET MVC: Los atributos personalizados funcionan de manera transparente con el sistema de validación de ASP.NET MVC, simplificando su uso.
• Validación en el Servidor: Al realizar la validación en el servidor, se garantiza que las reglas de negocio se apliquen correctamente, independientemente del entorno del cliente.

 

 

Creando una Validación Personalizada con ValidationAttribute

Para ilustrar cómo crear una validación personalizada, vamos a desarrollar un atributo de validación que asegure que una propiedad de cadena no contenga ciertas palabras prohibidas.

 

Paso 1: Crear la Clase de Validación Personalizada

Comenzaremos creando una clase PalabrasProhibidasAttribute que herede de ValidationAttribute y sobrescribiremos el método IsValid, donde definiremos la lógica de validación.

Ejemplo de Clase de Validación Personalizada PalabrasProhibidasAttribute.cs :

using System;
using System.ComponentModel.DataAnnotations;
using System.Linq;

public class PalabrasProhibidasAttribute : ValidationAttribute
{
    private readonly string[] _palabrasProhibidas;

    public PalabrasProhibidasAttribute(string[] palabrasProhibidas)
    {
        _palabrasProhibidas = palabrasProhibidas ?? throw new ArgumentNullException(nameof(palabrasProhibidas));
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        // Si el valor es nulo, la validación es exitosa
        if (value == null)
        {
            return ValidationResult.Success;
        }

        // Convertir el valor en una cadena para su validación
        var stringValue = value.ToString();

        // Verificar si la cadena contiene alguna palabra prohibida
        foreach (var palabra in _palabrasProhibidas)
        {
            if (stringValue.Contains(palabra, StringComparison.OrdinalIgnoreCase))
            {
                // Retornar un mensaje de error si se encuentra una palabra prohibida
                return new ValidationResult(
                    ErrorMessage ?? $"{validationContext.DisplayName} contiene palabras prohibidas.");
            }
        }

        // Si no se encuentran palabras prohibidas, la validación es exitosa
        return ValidationResult.Success;
    }
}

Explicación del Código:

• Constructor: El constructor de PalabrasProhibidasAttribute toma un array de strings (palabrasProhibidas) como parámetro y lo almacena en un campo privado. Si no se proporcionan palabras, se lanza una excepción.
• Método IsValid: Este método es el núcleo de la validación. Primero, verifica si el valor es nulo; si es así, se considera válido (ya que la validación de obligatoriedad se maneja por separado). Luego, convierte el valor en una cadena y revisa si contiene alguna de las palabras prohibidas. Si encuentra una coincidencia, retorna un ValidationResult con un mensaje de error; si no, retorna ValidationResult.Success.
• Operador (??) : El operador ?? en C# es un operador "null-coalescing". Este operador evalúa la expresión de la izquierda y, si es null, retorna la expresión de la derecha. Esto significa: Si ErrorMessage tiene un valor (no es null), se usará ese valor, Si ErrorMessage es null, se usará el mensaje predeterminado "${validationContext.DisplayName} contiene palabras prohibidas.".
• validationContext.DisplayName: Es una propiedad que devuelve el nombre que se muestra para la propiedad que se está validando. Esto generalmente es el nombre de la propiedad en el modelo, pero podría ser un nombre más amigable si se configuró un atributo [Display(Name = "Nombre Amigable")] en la propiedad del modelo.

Nota: Cuando aplicas el atributo[PalabrasProhibidas] a una propiedad de un Modelo, el array de palabras prohibidas que le pasas , se asigna al parámetro del constructor de la clase PalabrasProhibidasAttribute.

 

Paso 2: Aplicar el Atributo Personalizado en un Modelo

Una vez que hemos creado nuestro atributo de validación personalizada, podemos aplicarlo a las propiedades del modelo que necesitan esta validación.

Ejemplo de Modelo BlogPost.cs:

using System.ComponentModel.DataAnnotations;

public class BlogPost
{
    public int Id { get; set; }

    [Required(ErrorMessage = "El título es obligatorio.")]
    [StringLength(100, ErrorMessage = "El título no puede tener más de 100 caracteres.")]
    [PalabrasProhibidas(new string[] { "spam", "publicidad", "prohibido" }, ErrorMessage = "El título contiene contenido inapropiado.")]
    public string Titulo { get; set; }

    [Required(ErrorMessage = "El contenido es obligatorio.")]
    [PalabrasProhibidas(new string[] { "spam", "publicidad", "prohibido" }, ErrorMessage = "El contenido contiene contenido inapropiado.")]
    public string Contenido { get; set; }

    public DateTime FechaPublicacion { get; set; }
}

Explicación del Código:

• Propiedad Titulo: Además de las validaciones estándar como [Required] y [StringLength], se aplica la validación personalizada [PalabrasProhibidas] para asegurar que el título no contenga palabras inapropiadas.
• Propiedad Contenido: De manera similar, el contenido del post se valida para evitar palabras prohibidas.

Nota: La clase de validación personalizada se llama PalabrasProhibidasAttribute porque sigue la convención de C# de agregar "Attribute" al final del nombre de las clases que representan atributos. Sin embargo, cuando aplicas este atributo en el código de tu Modelo, puedes omitir el sufijo "Attribute" y simplemente usar [PalabrasProhibidas], lo cual es una característica de la sintaxis de C# diseñada para hacer el código más limpio y legible.

 

Paso 3: Implementar el Controlador

El siguiente paso es implementar el controlador BlogController que manejará la lógica de creación de un blog post, utilizando el modelo con las validaciones personalizadas BlogPost.

Ejemplo de Controlador BlogController.cs :

using System;
using System.Web.Mvc;

public class BlogController : Controller
{
    private readonly ApplicationDbContext _context;

    public BlogController()
    {
        _context = new ApplicationDbContext();
    }

    // GET: Blog/Create
    public ActionResult Crear()
    {
        return View();
    }

    // POST: Blog/Create
    [HttpPost]
    [ValidateAntiForgeryToken]
    public ActionResult Crear(BlogPost modelo)
    {
        if (ModelState.IsValid)
        {
            modelo.FechaPublicacion = DateTime.Now;
            _context.BlogPosts.Add(modelo);
            _context.SaveChanges();
            return RedirectToAction("Index");
        }

        // Si el modelo no es válido, se vuelve a mostrar la vista con los errores.
        return View(modelo);
    }

    // GET: Blog/Index
    public ActionResult Index()
    {
        var posts = _context.BlogPosts.ToList();
        return View(posts);
    }
}

Explicación del Código:

• Acción Crear (GET): Muestra la vista para crear un nuevo blog post.
• Acción Crear (POST): Verifica si el ModelState es válido, lo que significa que todas las validaciones han pasado, incluyendo las validaciones personalizadas. Si es válido, guarda el nuevo post en la base de datos y redirige al usuario a la lista de posts; si no es válido, muestra la vista nuevamente con los errores de validación.
• Acción Index: Muestra una lista de todos los blog posts existentes.

 

Paso 4: Crear la Vista para el Formulario

Ahora, necesitamos crear la vista que contiene el formulario para crear un nuevo blog post. Esta vista debe mostrar los errores de validación en caso de que el usuario ingrese datos inválidos.

Ejemplo de Vista Crear.cshtml:

@model TuNamespace.Models.BlogPost

@{
    ViewBag.Title = "Crear Blog Post";
}

<h2>Crear Blog Post</h2>

@using (Html.BeginForm()) 
{
    @Html.AntiForgeryToken()
    
    <div class="form-horizontal">
        <h4>Blog Post</h4>
        <hr />
        @Html.ValidationSummary(true, "", new { @class = "text-danger" })
        
        <div class="form-group">
            @Html.LabelFor(model => model.Titulo, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Titulo, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Titulo, "", new { @class = "text-danger" })
            </div>
        </div>
        
        <div class="form-group">
            @Html.LabelFor(model => model.Contenido, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.TextAreaFor(model => model.Contenido, new { @class = "form-control", rows = 5 })
                @Html.ValidationMessageFor(model => model.Contenido, "", new { @class = "text-danger" })
            </div>
        </div>
        
        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Crear" class="btn btn-default" />
            </div>
        </div>
    </div>
}

Explicación del Código:

• @Html.ValidationSummary: Este helper muestra un resumen de todos los errores de validación en la parte superior del formulario.
• @Html.ValidationMessageFor: Este helper muestra mensajes de error específicos para una propiedad en particular, como Titulo o Contenido.
• Campos del formulario: Los campos Titulo y Contenido están vinculados al modelo BlogPost, y los errores de validación se mostrarán junto a ellos si existen.

 

 

Buenas Prácticas para Validaciones Personalizadas en ASP.NET MVC

1. Mantén la Lógica de Validación Sencilla y Reutilizable:  Asegúrate de que tus validaciones personalizadas sean lo más simples y enfocadas posible. Si la lógica de validación se vuelve compleja, considera dividirla en varias validaciones pequeñas para mejorar la mantenibilidad.

2. Valida Siempre en el Servidor:  Aunque la validación del lado del cliente mejora la experiencia del usuario, siempre debes validar los datos en el servidor. Esto previene ataques maliciosos, ya que los usuarios pueden manipular fácilmente la validación del cliente.

3. Proporciona Mensajes de Error Claros:  Los mensajes de error deben ser específicos y claros para ayudar a los usuarios a corregir los problemas. Utiliza ErrorMessage para personalizar los mensajes y hacerlos más amigables.

4. Integra con el Sistema de Validación de ASP.NET MVC:  Asegúrate de que tus validaciones personalizadas se integren perfectamente con el sistema de validación de ASP.NET MVC, utilizando ValidationSummary y ValidationMessageFor para mostrar los errores en las vistas.

5. Considera el Rendimiento:  Si tu validación personalizada implica operaciones costosas, como consultas a la base de datos, considera realizar esas validaciones en una etapa diferente del ciclo de vida, o utiliza caché para mejorar el rendimiento.

 

 

Conclusiónes

La implementación de validaciones personalizadas en ASP.NET MVC utilizando ValidationAttribute permite un control detallado sobre las reglas de validación. Al encapsular la lógica de validación en atributos personalizados, los desarrolladores pueden asegurar que los datos ingresados sean correctos y cumplan con las reglas de negocio específicas antes de su procesamiento en el servidor.

Este artículo ha demostrado cómo crear y aplicar un atributo de validación personalizado en un modelo, integrar esta validación en el controlador, y mostrar los errores en una vista. Este enfoque asegura una validación robusta y flexible en las aplicaciones web, mejorando la integridad y seguridad de los datos.