ASP.NET MVC: convalida personalizzata da DataAnnotation

Ho un modello con 4 proprietà che sono di tipo stringa. So che puoi convalidare la lunghezza di una singola proprietà utilizzando l'annotazione StringLength. Tuttavia voglio convalidare la lunghezza delle 4 proprietà combinate.

Qual è il modo MVC per farlo con l'annotazione dei dati?

Lo chiedo perché sono nuovo in MVC e voglio farlo nel modo corretto prima di creare la mia soluzione.

Puoi scrivere un attributo di convalida personalizzato:

public class CombinedMinLengthAttribute: ValidationAttribute
{
    public CombinedMinLengthAttribute(int minLength, params string[] propertyNames)
    {
        this.PropertyNames = propertyNames;
        this.MinLength = minLength;
    }

    public string[] PropertyNames { get; private set; }
    public int MinLength { get; private set; }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var properties = this.PropertyNames.Select(validationContext.ObjectType.GetProperty);
        var values = properties.Select(p => p.GetValue(validationContext.ObjectInstance, null)).OfType<string>();
        var totalLength = values.Sum(x => x.Length) + Convert.ToString(value).Length;
        if (totalLength < this.MinLength)
        {
            return new ValidationResult(this.FormatErrorMessage(validationContext.DisplayName));
        }
        return null;
    }
}

e quindi potresti avere un modello di visualizzazione e decorare una delle sue proprietà con esso:

public class MyViewModel
{
    [CombinedMinLength(20, "Bar", "Baz", ErrorMessage = "The combined minimum length of the Foo, Bar and Baz properties should be longer than 20")]
    public string Foo { get; set; }
    public string Bar { get; set; }
    public string Baz { get; set; }
}

Modello auto convalidato

Il tuo modello dovrebbe implementare un'interfaccia IValidatableObject. Inserisci il tuo codice di convalida nel Validatemetodo:

public class MyModel : IValidatableObject
{
    public string Title { get; set; }
    public string Description { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        if (Title == null)
            yield return new ValidationResult("*", new [] { nameof(Title) });

        if (Description == null)
            yield return new ValidationResult("*", new [] { nameof(Description) });
    }
}

Nota: questa è una convalida lato server . Non funziona sul lato client. La convalida verrà eseguita solo dopo l'invio del modulo.

ExpressiveAnnotations ti offre questa possibilità:

[Required]
[AssertThat("Length(FieldA) + Length(FieldB) + Length(FieldC) + Length(FieldD) > 50")]
public string FieldA { get; set; }

Per migliorare la risposta di Darin, può essere un po 'più breve:

public class UniqueFileName : ValidationAttribute
{
    private readonly NewsService _newsService = new NewsService();

    public override bool IsValid(object value)
    {
        if (value == null) { return false; }

        var file = (HttpPostedFile) value;

        return _newsService.IsFileNameUnique(file.FileName);
    }
}

Modello:

[UniqueFileName(ErrorMessage = "This file name is not unique.")]

Tieni presente che è richiesto un messaggio di errore, altrimenti l'errore sarà vuoto.

Sfondo:

Le convalide del modello sono necessarie per garantire che i dati ricevuti che riceviamo siano validi e corretti in modo da poter eseguire l'ulteriore elaborazione con questi dati. Possiamo convalidare un modello in un metodo di azione. Gli attributi di convalida incorporati sono Compare, Range, RegularExpression, Required, StringLength. Tuttavia, potremmo avere scenari in cui abbiamo richiesto attributi di convalida diversi da quelli incorporati.

Attributi di convalida personalizzati

public class EmployeeModel 
{
    [Required]
    [UniqueEmailAddress]
    public string EmailAddress {get;set;}
    public string FirstName {get;set;}
    public string LastName {get;set;}
    public int OrganizationId {get;set;}
}

Per creare un attributo di convalida personalizzato, dovrai derivare questa classe da ValidationAttribute.

public class UniqueEmailAddress : ValidationAttribute
{
    private IEmployeeRepository _employeeRepository;
    [Inject]
    public IEmployeeRepository EmployeeRepository
    {
        get { return _employeeRepository; }
        set
        {
            _employeeRepository = value;
        }
    }
    protected override ValidationResult IsValid(object value,
                        ValidationContext validationContext)
    {
        var model = (EmployeeModel)validationContext.ObjectInstance;
        if(model.Field1 == null){
            return new ValidationResult("Field1 is null");
        }
        if(model.Field2 == null){
            return new ValidationResult("Field2 is null");
        }
        if(model.Field3 == null){
            return new ValidationResult("Field3 is null");
        }
        return ValidationResult.Success;
    }
}

Spero che questo ti aiuti. Saluti !

Riferimenti

• Progetto codice: attributo di convalida personalizzato in ASP.NET MVC3
• Haacked - Convalida personalizzata ASP.NET MVC 2

Un po 'tardi per rispondere, ma per chi sta cercando. Puoi farlo facilmente usando una proprietà extra con l'annotazione dei dati:

public string foo { get; set; }
public string bar { get; set; }

[MinLength(20, ErrorMessage = "too short")]
public string foobar 
{ 
    get
    {
        return foo + bar;
    }
}

Questo è tutto ciò che è davvero. Se vuoi davvero visualizzare in un posto specifico anche l'errore di convalida, puoi aggiungerlo nella tua vista:

@Html.ValidationMessage("foobar", "your combined text is too short")

farlo nella vista può tornare utile se vuoi fare la localizzazione.

Spero che questo ti aiuti!