Validando sin parar. Uso de DataAnnotations

Introducción

Como pasa en muchos casos, el otro día me encontraba haciendo pruebecillas e implementando diferentes procesos de validación en Dtos y entidades.

Al finalizar mis pruebas, el resultado de todo es un conjunto de clases que hacía justo lo que quería respecto a las validaciones.

Decoraba mis clases y/o miembros como deseaba, y en base a esa decoración, ejecutaba el proceso de validación que me permitía obtener qué miembros no habían cumplido esa validación y porqué.

Sin embargo, mientras estaba desarrollando todo esto, me venía a la mente que existía “algo” para hacer si no esto mismo, sí algo muy muy similar. No obstante y ya que estaba metido en el fregado, decidí avanzar por aquello de refrescar/aprender cosas. Cuando acabé me puse a pensar más profundamente y caí en la cuenta de algo que llamaba DataAnnotations o similar.

El caso es que DataAnnotations me habría ahorrado mucho tiempo, así que aquí lo pongo para aquellos que se encuentren en una tesitura parecida y no pierdan el tiempo rehaciendo la rueda como hice yo (si bien nunca viene mal para refrescar/aprender cosas).

En esta entrada, voy a comentaros en qué consiste y como utilizar DataAnnotations en vuestros desarrollos de .NET.

¿En qué consiste DataAnnotations?

Básicamente, DataAnnotations nos permite llevar a cabo validaciones de datos de acuerdo a nuestras necesidades. Esas necesidades son decoraciones que indicaremos a los miembros de nuestras entidades y Dtos. Una decoración corresponderá a una validación.

¿Qué ensamblado es el que entra en juego con las clases de DataAnnotations?

Para «jugar» con DataAnnotations, deberemos agregar un ensamblado a las referencias de nuestro proyecto. Este ensamblado es System.ComponentModel.DataAnnotations.

¿Cómo marcamos el tipo de validación de un miembro?

Para marcar el tipo de validación de un miembro, utilizaremos diferentes atributos.

Estos atributos pueden anidarse de manera que un campo pueda tener más de una validación.

Entre estos atributos encontramos los siguientes:

• Required: perteneciente a System.ComponentModel.DataAnnotations.RequiredAttribute, marca que el miembro debe tener un campo obligatorio. Esta decoración puede ser utilizada junto a ErrorMessage para indicar un mensaje personalizado de error en el caso de que no se cumpla esta validación.
• Range: perteneciente a System.ComponentModel.DataAnnotations.RangeAttribute, marca un rango de valores entre los que debe estar comprendido el valor pasado al miembro.
• StringLength: perteneciente a System.ComponentModel.DataAnnotations.StringLengthAttribute, indica un tamaño del campo string. Esta decoración puede ir en conjunción con MinimunLength para indicar incluso un tamaño mínimo del campo string.
• RegularExpression: perteneciente a System.ComponentModel.DataAnnotations.RegularExpressionAttribute, indica una expresión regulada que debe ser utilizada para validar el miembro.
• DataType: perteneciente a System.ComponentModel.DataAnnotations.DataTypeAttribute, indica un nombre de un tipo adicional que debe asociarse a un campo de datos.
• CustomValidation: perteneciente a System.ComponentModel.DataAnnotations.CustomValidationAttribute, nos permite validar a través de validaciones personalizadas.

Vamos con un ejemplo

Y como siempre, la mejor forma de ver esto en funcionamiento es practicar con un ejemplo.

Imaginemos la siguiente situación. Debemos crear un objeto Persona que contendrá diferentes miembros:

• Id: identificador de la entidad. Campo no requerido.
• Nombre: nombre de la persona. Campo requerido. Campo de 25 caracteres máximo.
• Apellido: apellido de la persona. Campo requerido. Campo de 50 caracteres máximo.
• Dni: número del documento nacional de identidad de la persona. Campo requerido. Campo de más de 1 carácter y de hasta 8 caracteres.
• Teléfono: número telefónico de la persona. Campo no requerido. Campo de 9 a 13 cifras (aunque vamos a omitir la validación en este ejemplo).
• Mail: correo electrónico de la persona. Campo no requerido. Validable a través de una expresión regulada que verifica la validez de una cuenta de correo electrónico.

De acuerdo a los datos que tenemos, hemos preparado el código de nuestro objeto Persona de la siguiente manera:

   1: using System.ComponentModel.DataAnnotations;

   2:

   3:

   4: public sealed class Persona

   5: {

   6:

   7:     public int Id { get; set; }

   8:

   9:     [Required]

  10:     [StringLength(25)]

  11:     public string Nombre { get; set; }

  12:

  13:     [Required(ErrorMessage = "No te olvides del apellido")]

  14:     [StringLength(50)]

  15:     public string Apellido { get; set; }

  16:

  17:     [Required]

  18:     [StringLength(8, MinimumLength = 1)]

  19:     public string Dni { get; set; }

  20:

  21:     public long Telefono { get; set; }

  22:

  23:     [RegularExpres*ion("expression")]

  24:     public string Mail { get; set; }

  25:

  26: } // Persona

Nota: «expression» dentro de RegularExpression debe ser reemplazada por la expresión regulada correspondiente. Por alguna razón que desconozco, el sitio me está bloqueando la expresión regulada. La indicaré en los comentarios a esta entrada.

Una vez hecho esto, bastará con ejecutar una porción de código que se encargará de realizar las siguientes tareas:

• Crear la entidad Persona.
• Llevar a cabo el proceso de validación.
• En el caso de que existan errores de validación, recorrerlos para procesarlos como deseemos.

El código de ejecución y demostración del funcionamiento de la validación con DataAnnotations quedaría de la siguiente manera:

   1: // Creamos un objeto Persona y le agregamos valores

   2: Persona persona = new Persona();

   3: persona.Nombre = "José";

   4: //persona.Apellido = "López";

   5: persona.Dni = "1112233";

   6: persona.Mail = "joselopez@dominio.com";

   7: // Proceso de validación.

   8: ValidationContext validationContext = new ValidationContext(persona, null, null);

   9: List<ValidationResult> errors = new List<ValidationResult>();

  10: Validator.TryValidateObject(persona, validationContext, errors, true);

  11: // Si hay errores, los recorremos y los mostramos (versión demo).            

  12: if (errors.Count() > 0)

  13: {

  14:     string errorMessages = string.Empty;

  15:     foreach (var error in errors)

  16:     {

  17:         errorMessages += error.ErrorMessage + Environment.NewLine;

  18:     }

  19:     MessageBox.Show(errorMessages);

  20: }

  21: else

  22: {

  23:     MessageBox.Show("Entidad correcta");

  24: }

En este ejemplo, he querido dejar comentado intencionadamente la asignación de Apellido.

De esta manera, la validación devolverá un mensaje por pantalla parecido a este:

El mensaje corresponde con la validación del campo Apellido y cuyo mensaje en el caso de no pasar la validación, hemos querido personalizar con el texto “No te olvides del apellido”.

Evidentemente, en las otras validaciones tendríamos resultados parecidos.

De hecho, si por ejemplo quitara del correo electrónico el carácter @ tendría el siguiente resultado:

Como podemos observar, las validaciones se producen con muy poco esfuerzo.

Extensibilidad a la hora de hacer nuestras propias validaciones

Si quisiéramos extender las validaciones que ofrece .NET y que recoge casi todas las casuísticas, no tendríamos problemas.

Bastaría con crear nuestros propios atributos y heredar de ValidationAtttribute.

Como podemos ver, trabajar con DataAnnotations en nuestros desarrollos, puede resultarnos de utilidad y ahorrarnos mucho trabajo, además de aportarnos flexibilidad a la hora de desarrollar nuestras propias validaciones personalizadas.