Validación y librerías fluidas

Question

Mientras buscaba algo totalmente diferente el otro día, me encontré con dos bibliotecas para hacer Validación fluida en .NET. El concepto parece interesante ya que hasta ahora estoy haciendo mis validaciones usando las declaraciones usuales condicional y de ramificación (si, else, caso, etc.).

En particular, hace que sea relativamente fácil encadenar algunas condiciones que podrían dar lugar, en algunos casos, a códigos más cortos para condiciones complejas, e insertar varios mensajes de error por cada infracción en el mismo objeto.

Dicho esto, ¿no está haciendo que el código parezca más detallado de lo que normalmente es C#, un poco como T-SQL puede ser a veces ... y esto no causa que el código tenga una apariencia inconsistente y ¿sensación?

En resumen, ¿qué piensas de Validación fluida y, si te gusta, qué biblioteca crees que es la mejor para ella? Hasta ahora, he visto http://tnvalidate.codeplex.com/ y http://fluentvalidation.codeplex.com/ que parecen más o menos equivalentes a primera vista ...

Gracias.

Answer 1

Estoy usando mi propia biblioteca de validación que publiqué here.

La diferencia con los dos que sugirió es que las validaciones se colocan en clases de validación separadas. Puede crear y olvidar las clases de validación, las descubre automáticamente la biblioteca de validación.

public class MyModelValidator : FluentValidator<MyModel> 
{ 
    public MyModelValidator() 
    { 
    Property("FirstName").Required(); 
    Property("LastName").Required().Min(15); 
    } 
} 

También es fácil de añadir soporte para localizaciones utilizando su propio libray localización favorito (como una tabla de cadenas)

public class StringTableProvider : ILanguagePrompts 
{ 
    public string this[string modelName, string propertyName] 
    { 
     get { return Get(modelName, propertyName) ?? "[" + propertyName+ "]"; } 
    } 

    public string Get(string modelName, string propertyName) 
    { 
     return Resource1.ResourceManager.GetString(modelName + "_" + propertyName); 
    } 
} 

y para configurar:

Validator.LanguageHandler = new StringTableProvider(); 

La validación real se hace así:

User user = new User(); 
user.FirstName = "Jonas"; 

var errors = Validator.Validate(user); 
if (errors.Count > 0) 
{ 
    // Handle the errors in any way you like. 
    // both property names (localized and actual property name) and localized error message is accessible. 
} 

Answer 2

Me tropecé con algo similar por mi cuenta, y lo escribí precisamente para que el código fuera MENOS detallado.

tengo mi propia validación donde hago cosas como:

Validation.IsNullOrEmpty(m => m.FirstName, modelState); 
Validation.Validate(m => m.ZipCode, z => z.Length == 5, modelState, 
"ZipCode must be 5 characters long"); 

Ahora bien, esto está ligado muy de cerca a la arquitectura MVC estoy usando, pero me parece que para ser más fácil de leer y mantener que:

if (string.IsNullOrEmpty(FirstName)) 
{ 
    ModelState.AddError("FirstName", "FirstName cannot be empty."); 
} 

En este contexto, no es tan notable, pero cuando lo hace la validación, puede tener elementos MUCHAS para validar, por lo que los trazadores de líneas uno vuelto mucho más fácil para escanear y averiguar lo que la validación está haciendo.

Tienes la primera vez que te topas con el primer código que coloco allí y tienes que descubrir lo que está pasando, pero una vez que pasas eso, creo que un montón de líneas son más fáciles para los ojos que los bloques múltiples que producirá el segundo método.

Answer 3

También hay http://rulesengine.codeplex.com/ que utiliza una clase auxiliar de interfaz fluida para agregar reglas a un motor (que luego se usa para validar objetos).

Soporta composición, campo cruzado, condicional, varios idiomas, etc ...