Validación manual del Modelo con "Data Annotations"

Cuando se usa una validación de Modelo con "Data Annotations", el Framework MVC usualmente manejará la mayor parte de los procesos para efectuar la validación e incluso mostrará los resultados al usuario final de la forma que tu quieres. Sin embargo, como ya lo discutimos, lo bueno del patrón MVC es la separación de los asuntos. Esto significa que mientras podrías construir una buena colección de Modelos para representar todos los datos de tu aplicación web, estos Modelos también podrían ser usados fuera del Framework MVC, p.ej. en una aplicación de escritorio. Como es esto posible? Porque los Modelos son solo clases regulares de .NET!

Pero por que podrías necesitar usar los Modelos fuera del Framework MVC? Bueno, hay una buena posibilidad de que no lo hagas - realmente depende en lo que estés trabajando. Pero por ejemplo, considera un proyecto grande, donde necesitas automatizar algunas acciones y ejecutarlas directamente desde la línea de comandos en vez que desde el sitio web. Esto te permitirá agendar estas acciones a través del Programador de Tareas de Windows (o como una tarea cron en os*nix), sin tener que preocuparte de los tiempos muertos u otras limitaciones relacionadas con la web.

En un caso como este, puedes fácilmente reusar tus Modelos en otros tipos de aplicaciones, p.ej. Aplicaciones de Consola - solo agregando una referencia al proyecto donde tienes tus Modelos (el cual puede ser un proyecto separado o parte de tu proyecto web) y comenzar a usar las clases exactamente como lo harías con cualquier otra clase. Esto es genial, pero que de tus validaciones? Como el Framework MVC maneja gran parte de la "Magia" involucrada en las ejecución de las validaciones, no está muy claro como ganar ventaja de las reglas de validación que has agregado a tus Modelos usando "Data Annotations".

Ejecutando una validación de Modelo manual

Déjame demostrar como lograr esto. Tenemos el Modelo WebUser, el que hemos usado en ejemplos anteriores en este capítulo:

public class WebUser
{
    [Required]
    [StringLength(25)]
    public string FirstName { get; set; }

    [Required]
    [StringLength(50, MinimumLength = 3)]
    public string LastName { get; set; }

    [Required]
    [EmailAddress]
    public string MailAddress { get; set; }
}

Como puedes ver, sus propiedades han sido decoradas sutilmente con anotaciones para validación, especificando todos los requerimientos - Estas reglas son de las que queremos tomar ventaja fuera de la aplicación MVC. Por lo tanto he creado, dentro de la misma solución, un proyecto para una aplicación de Consola con el fin de demostrar esto. Obviamente, esto es solo para demostrar una alternativa para este mecanismo en ciertos casos - tu puedes usar el mismo enfoque en tu aplicación MVC en caso de que, por alguna razón, quieras más control sobre el proceso de validación. He aquí nuestra App de Consola:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using WebApp.Models;

namespace TaskRunner
{
    class Program
    {
    static void Main(string[] args)
    {
        Console.WriteLine("Starting validation:");

        WebUser user = new WebUser();
        user.FirstName = null;
        user.LastName = "aa";
        user.MailAddress = "blah@blah@blah";

        var context = new ValidationContext(user, null, null);
        var results = new List<ValidationResult>();

        var isValid = Validator.TryValidateObject(user, context, results, true);

        if(!isValid)
        {
        Console.WriteLine("User is NOT valid! Errors:");
        foreach(var validationResult in results)
        {
            Console.WriteLine(validationResult.ErrorMessage);
        }
        }
        Console.WriteLine("Done...");
        Console.ReadKey();
    }
    }
}

Lo que hacemos aquí es bastante simple. He creado un nuevo objeto WebUser y luego, deliberadamente, he asignado valores no validos, para comprobar la validación. Luego creamos ValidationContext, basado en el objeto WebUser, como también una lista para almacenar los valores de retorno de ValidationResult. La línea más interesante es donde llamamos al método Validator.TryValidateObject(). Esto validará el objeto WebServer (primer parámetro), usando ValidationContext (segundo parámetro) y asignará el resultado a las variables resultantes (tercer parámetro). El cuarto parámetro especifica que TODAS las propiedades deberían ser validadas, no solo las requeridas. La salida en la Consola lucirá como esto:

Starting validation:
User is NOT valid! Errors:
The FirstName field is required.
The field LastName must be a string with a minimum length of 3 and a maximum length of 50.
The MailAddress field is not a valid e-mail address.
Done...

Sumario

Usando unas pocas líneas de código, podemos sacar ventaja de las reglas de validación declaradas en el Modelo usando "Data Annotations" y validar Modelos cuando queramos y hacer lo que queramos con los resultados. Esto puede ser útil en varias situaciones, p.ej. cuando quieras reusar las reglas de validación fuera del Framework MVC o cuando quieres control total sobre el proceso de validación.