Quale framework di convalida MVC

Question

Sto valutando xVal come framework per la validazione di Entità in ASP.Net MVC Framework. Di recente ho scoperto che ogni volta che una regola di convalida viene infranta, xVal provoca un'eccezione. Per me sembra errato. Ad esempio, quando un utente compila un modulo e si dimentica di compilare tre campi obbligatori, verranno generate tre eccezioni. Questa è una buona pratica? (Modifica: Ho letto anche questo, quindi immagino che non sia una buona pratica)

Quali sono le tue esperienze di utilizzo di xVal? Esiste un buon framework di convalida alternativo che non genera eccezioni?

Grazie

(PS: noto che molte persone leggono questo, solo per farti sapere Sto usando la validazione fluida ora)

Answer 1

Hai esaminato la convalida in Beta 2?

http://blogs.msdn.com/rickandy/archive/2009/10/03/client-side-validation-for-mvc-2-p2.aspx

Answer 2

No, non è una buona pratica mostrare eccezioni invece di alcuni semplici messaggi perché nulla di grave è andato storto ... Dovresti invece compilare ModelState con questi errori e visualizzarli sul modulo usando

Html.ValidationMessage("EntityPropertyName");

xVal supporta tutti questi. Oltre a convalidare sul lato client prima che il modulo venga posticipato.

Alcuni codici

Quando imposti gli attributi DataAnnotations sulle tue classi di entità (o sulle loro classi di metadati associate) molto probabilmente implementerai anche il metodo Validate (). il modo migliore sarebbe usare T4 che genererà automaticamente quelli per te, quindi non devi ripetere lo stesso codice ancora e ancora ...

public IEnumerable<ErrorInfo> Validate()
{
    IList<ErrorInfo> errors = DataAnnotationsValidationRunner.GetErrors(this).ToList<ErrorInfo>();
    return errors.AsEnumerable();
}

Tutto quello che devi fare è chiamare questo:

IEnumerable<ErrorInfo> errors = entityObjectInstance.Validate();
if (errors.Any())
{
    new RulesException(errors).AddModelStateErrors(filterContext.Controller.ViewData.ModelState, entityPropertyName);
}

E per automatizzare ulteriormente ciò, è possibile implementarlo in un filtro di azione, quindi la convalida sarà automatica per gli oggetti entità che vengono passati all'azione del controller. Le azioni del controller dovrebbero solo verificare se ModelState.IsValid () quindi.

Un'altra classe di cui hai bisogno è (ed è presa dal web da qualche parte):

public static class DataAnnotationsValidationRunner
{
    public static IEnumerable<ErrorInfo> GetErrors(object instance)
    {
        var metadataAttribute = instance.GetType().GetCustomAttributes(typeof(MetadataTypeAttribute), true).OfType<MetadataTypeAttribute>().FirstOrDefault();
        var metaClass = metadataAttribute != null ? metadataAttribute.MetadataClassType : instance.GetType();
        var metaClassProperties = TypeDescriptor.GetProperties(metaClass).Cast<PropertyDescriptor>();
        var modelClassProperties = TypeDescriptor.GetProperties(instance.GetType()).Cast<PropertyDescriptor>();

        return from metaProp in metaClassProperties
               join modelProp in modelClassProperties on metaProp.Name equals modelProp.Name
               from attribute in metaProp.Attributes.OfType<ValidationAttribute>()
               where !attribute.IsValid(modelProp.GetValue(instance))
               select new ErrorInfo(metaProp.Name, attribute.FormatErrorMessage(string.Empty), instance);
    }
}

MVC 2

La convalida in Asp.net MVC 2 Beta 2 è simile a quella di xVal. Quindi, se non sei troppo avanti nel progetto e puoi prendere in considerazione l'uso del codice nei progressi dello sviluppo come base, forse questo è il modo giusto per te.

Answer 3

Penso che xVal sia fantastico, lo sto usando con Castle Validators e funziona perfettamente. Cattura l'eccezione RulesException ogni volta che esegui la convalida e aggiungi gli errori a ModelState, ad esempio

try
{
  // execute validation runner
}
catch (RulesException ex)
{
   ex.AddModelStateErrors(ModelState, "prefix");
}

ASP.NET MVC v2 introdurrà il proprio framework di validazione .