ASP.NET MVC: Benutzerdefinierte Validierung durch DataAnnotation

Ich habe ein Modell mit 4 Eigenschaften vom Typ Zeichenfolge. Ich weiß, dass Sie die Länge einer einzelnen Eigenschaft mithilfe der StringLength-Annotation überprüfen können. Ich möchte jedoch die Länge der 4 kombinierten Eigenschaften überprüfen.

Wie kann MVC dies mit Datenanmerkungen tun?

Ich frage dies, weil ich neu bei MVC bin und es richtig machen möchte, bevor ich meine eigene Lösung mache.

Sie können ein benutzerdefiniertes Validierungsattribut schreiben:

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;
    }
}

und dann könnten Sie ein Ansichtsmodell haben und eine seiner Eigenschaften damit dekorieren:

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; }
}

Selbst validiertes Modell

Ihr Modell sollte eine Schnittstelle implementieren IValidatableObject. Geben Sie Ihren Validierungscode in die folgende ValidateMethode ein:

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) });
    }
}

Bitte beachten Sie: Dies ist eine serverseitige Validierung. Auf Client-Seite funktioniert es nicht. Ihre Validierung wird erst nach dem Absenden des Formulars durchgeführt.

ExpressiveAnnotations bietet Ihnen eine solche Möglichkeit:

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

Um Darins Antwort zu verbessern, kann sie etwas kürzer sein:

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);
    }
}

Modell:

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

Beachten Sie, dass eine Fehlermeldung erforderlich ist, da sonst der Fehler leer ist.

Hintergrund:

Modellvalidierungen sind erforderlich, um sicherzustellen, dass die empfangenen Daten, die wir erhalten, gültig und korrekt sind, damit wir die weitere Verarbeitung mit diesen Daten durchführen können. Wir können ein Modell in einer Aktionsmethode validieren. Die integrierten Validierungsattribute sind Compare, Range, RegularExpression, Required, StringLength. Möglicherweise haben wir jedoch Szenarien, in denen wir andere als die integrierten Validierungsattribute benötigen.

Benutzerdefinierte Validierungsattribute

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;}
}

Um ein benutzerdefiniertes Validierungsattribut zu erstellen, müssen Sie diese Klasse von ValidationAttribute ableiten.

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;
    }
}

Hoffe das hilft. Prost !

Verweise

• Code Project - Benutzerdefiniertes Validierungsattribut in ASP.NET MVC3
• Haacked - Benutzerdefinierte ASP.NET MVC 2-Validierung

Ein bisschen spät zu antworten, aber für wen sucht. Sie können dies einfach tun, indem Sie eine zusätzliche Eigenschaft mit der Datenanmerkung verwenden:

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

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

Das ist alles, was es wirklich ist. Wenn Sie den Validierungsfehler wirklich auch an einer bestimmten Stelle anzeigen möchten, können Sie diesen in Ihrer Ansicht hinzufügen:

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

Dies in der Ansicht zu tun, kann nützlich sein, wenn Sie eine Lokalisierung durchführen möchten.

Hoffe das hilft!