ASP.NET MVC Bedingte Validierung

Wie verwende ich Datenanmerkungen, um eine bedingte Validierung des Modells durchzuführen?

Nehmen wir zum Beispiel an, wir haben das folgende Modell (Person und Senior):

public class Person
{
    [Required(ErrorMessage = "*")]
    public string Name
    {
        get;
        set;
    }

    public bool IsSenior
    {
        get;
        set;
    }

    public Senior Senior
    {
        get;
        set;
    }
}

public class Senior
{
    [Required(ErrorMessage = "*")]//this should be conditional validation, based on the "IsSenior" value
    public string Description
    {
        get;
        set;
    }
}

Und die folgende Ansicht:

<%= Html.EditorFor(m => m.Name)%>
<%= Html.ValidationMessageFor(m => m.Name)%>

<%= Html.CheckBoxFor(m => m.IsSenior)%>
<%= Html.ValidationMessageFor(m => m.IsSenior)%>

<%= Html.CheckBoxFor(m => m.Senior.Description)%>
<%= Html.ValidationMessageFor(m => m.Senior.Description)%>

Ich möchte das bedingte Pflichtfeld "Senior.Description" sein, das auf der Auswahl der Eigenschaft "IsSenior" basiert (true -> erforderlich). Wie implementiere ich die bedingte Validierung in ASP.NET MVC 2 mit Datenanmerkungen?

Es gibt eine viel bessere Möglichkeit, bedingte Validierungsregeln in MVC3 hinzuzufügen. Lassen Sie Ihr Modell IValidatableObjectdie ValidateMethode erben und implementieren :

public class Person : IValidatableObject
{
    public string Name { get; set; }
    public bool IsSenior { get; set; }
    public Senior Senior { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext) 
    { 
        if (IsSenior && string.IsNullOrEmpty(Senior.Description)) 
            yield return new ValidationResult("Description must be supplied.");
    }
}

Weitere Informationen finden Sie unter Einführung in ASP.NET MVC 3 (Vorschau 1) .

Ich habe dies durch die Behandlung des "ModelState" gelöst. -Wörterbuch behandelt habe, das in der Steuerung enthalten ist. Das ModelState-Wörterbuch enthält alle Mitglieder, die validiert werden müssen.

Hier ist die Lösung:

Wenn Sie eine bedingte Validierung basierend auf einem Feld implementieren müssen (z. B. wenn A = true, ist B erforderlich), während Sie Fehlermeldungen auf Eigenschaftsebene beibehalten (dies gilt nicht für benutzerdefinierte Validatoren auf Objektebene), können Sie dies erreichen indem Sie "ModelState" behandeln, indem Sie einfach unerwünschte Validierungen daraus entfernen.

... In einer Klasse ...

public bool PropertyThatRequiredAnotherFieldToBeFilled
{
  get;
  set;
}

[Required(ErrorMessage = "*")] 
public string DepentedProperty
{
  get;
  set;
}

... Klasse geht weiter ...

... In einer Controller-Aktion ...

if (!PropertyThatRequiredAnotherFieldToBeFilled)
{
   this.ModelState.Remove("DepentedProperty");
}

...

Damit erreichen wir eine bedingte Validierung, während alles andere gleich bleibt.

AKTUALISIEREN:

Dies ist meine endgültige Implementierung: Ich habe eine Schnittstelle für das Modell und das Aktionsattribut verwendet, das das Modell validiert, das diese Schnittstelle implementiert. Die Schnittstelle schreibt die Validate-Methode (ModelStateDictionary modelState) vor. Das Attribut on action ruft nur Validate (modelState) für IValidatorSomething auf.

Ich wollte diese Antwort nicht komplizieren, deshalb habe ich die endgültigen Implementierungsdetails (die am Ende im Produktionscode eine Rolle spielen) nicht erwähnt.

Ich hatte gestern das gleiche Problem, aber ich habe es auf sehr saubere Weise gemacht, was sowohl für die clientseitige als auch für die serverseitige Validierung funktioniert.

Bedingung: Basierend auf dem Wert einer anderen Eigenschaft im Modell möchten Sie eine andere Eigenschaft erforderlich machen. Hier ist der Code

public class RequiredIfAttribute : RequiredAttribute
{
    private String PropertyName { get; set; }
    private Object DesiredValue { get; set; }

    public RequiredIfAttribute(String propertyName, Object desiredvalue)
    {
        PropertyName = propertyName;
        DesiredValue = desiredvalue;
    }

    protected override ValidationResult IsValid(object value, ValidationContext context)
    {
        Object instance = context.ObjectInstance;
        Type type = instance.GetType();
        Object proprtyvalue = type.GetProperty(PropertyName).GetValue(instance, null);
        if (proprtyvalue.ToString() == DesiredValue.ToString())
        {
            ValidationResult result = base.IsValid(value, context);
            return result;
        }
        return ValidationResult.Success;
    }
}

Hier ist PropertyName die Eigenschaft, für die Sie Ihre Bedingung festlegen möchten. DesiredValue ist der bestimmte Wert des PropertyName (der Eigenschaft), für den Ihre andere Eigenschaft für erforderlich validiert werden muss

Angenommen, Sie haben Folgendes

public class User
{
    public UserType UserType { get; set; }

    [RequiredIf("UserType", UserType.Admin, ErrorMessageResourceName = "PasswordRequired", ErrorMessageResourceType = typeof(ResourceString))]
    public string Password
    {
        get;
        set;
    }
}

Registrieren Sie zu guter Letzt den Adapter für Ihr Attribut, damit es eine clientseitige Validierung durchführen kann (ich habe ihn in global.asax, Application_Start eingefügt).

 DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredIfAttribute),typeof(RequiredAttributeAdapter));

Ich habe dieses erstaunliche Nuget verwendet, das dynamische Anmerkungen ExpressiveAnnotations ausführt

Sie können jede Logik validieren, von der Sie träumen können:

public string Email { get; set; }
public string Phone { get; set; }
[RequiredIf("Email != null")]
[RequiredIf("Phone != null")]
[AssertThat("AgreeToContact == true")]
public bool? AgreeToContact { get; set; }

Sie können Validatoren bedingt deaktivieren, indem Sie Fehler aus ModelState entfernen:

ModelState["DependentProperty"].Errors.Clear();

Danke Merritt :)

Ich habe dies gerade auf MVC 3 aktualisiert, falls jemand es nützlich findet: Bedingte Validierung in ASP.NET MVC 3 .

Es gibt jetzt ein Framework, das diese bedingte Validierung (neben anderen praktischen Validierungen von Datenanmerkungen) sofort durchführt: http://foolproof.codeplex.com/

Schauen Sie sich insbesondere den Validator [RequiredIfTrue ("IsSenior")] an. Sie platzieren dies direkt in der Eigenschaft, die Sie validieren möchten, damit Sie das gewünschte Verhalten des Validierungsfehlers erhalten, der der Eigenschaft "Senior" zugeordnet ist.

Es ist als NuGet-Paket erhältlich.

Sie müssen auf Personenebene validieren, nicht auf Seniorenebene, oder Senior muss einen Verweis auf die übergeordnete Person haben. Es scheint mir, dass Sie einen Selbstvalidierungsmechanismus benötigen, der die Validierung für die Person und nicht für eine ihrer Eigenschaften definiert. Ich bin mir nicht sicher, aber ich glaube nicht, dass DataAnnotations dies sofort unterstützt. Was Sie tun können, um Ihre eigenen zu erstellen Attribute, die daraus abgeleitet werden ValidationAttribute, kann auf Klassenebene dekoriert werden. Als Nächstes erstellen Sie einen benutzerdefinierten Validator, mit dem auch diese Validatoren auf Klassenebene ausgeführt werden können.

Ich weiß, dass Validation Application Block die Selbstvalidierung sofort unterstützt, aber VAB hat eine ziemlich steile Lernkurve. Hier ist jedoch ein Beispiel für die Verwendung von VAB:

[HasSelfValidation]
public class Person
{
    public string Name { get; set; }
    public bool IsSenior { get; set; }
    public Senior Senior { get; set; }

    [SelfValidation]
    public void ValidateRange(ValidationResults results)
    {
        if (this.IsSenior && this.Senior != null && 
            string.IsNullOrEmpty(this.Senior.Description))
        {
            results.AddResult(new ValidationResult(
                "A senior description is required", 
                this, "", "", null));
        }
    }
}

Ich hatte das gleiche Problem, brauchte eine Änderung des Attributs [Erforderlich] - Feld erforderlich in Abhängigkeit von der http-Anfrage. Die Lösung ähnelte der Antwort von Dan Hunex, aber seine Lösung funktionierte nicht richtig (siehe Kommentare). Ich verwende keine unauffällige Validierung, sondern nur MicrosoftMvcValidation.js. Hier ist es. Implementieren Sie Ihr benutzerdefiniertes Attribut:

public class RequiredIfAttribute : RequiredAttribute
{

    public RequiredIfAttribute(/*You can put here pararmeters if You need, as seen in other answers of this topic*/)
    {

    }

    protected override ValidationResult IsValid(object value, ValidationContext context)
    {

    //You can put your logic here   

        return ValidationResult.Success;//I don't need its server-side so it always valid on server but you can do what you need
    }


}

Dann müssen Sie Ihren benutzerdefinierten Anbieter implementieren, um ihn als Adapter in Ihrer global.asax zu verwenden

public class RequreIfValidator : DataAnnotationsModelValidator <RequiredIfAttribute>
{

    ControllerContext ccontext;
    public RequreIfValidator(ModelMetadata metadata, ControllerContext context, RequiredIfAttribute attribute)
       : base(metadata, context, attribute)
    {
        ccontext = context;// I need only http request
    }

//override it for custom client-side validation 
     public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
     {       
               //here you can customize it as you want
         ModelClientValidationRule rule = new ModelClientValidationRule()
         {
             ErrorMessage = ErrorMessage,
    //and here is what i need on client side - if you want to make field required on client side just make ValidationType "required"    
             ValidationType =(ccontext.HttpContext.Request["extOperation"] == "2") ? "required" : "none";
         };
         return new ModelClientValidationRule[] { rule };
      }
}

Und ändern Sie Ihre global.asax mit einer Linie

DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredIfAttribute), typeof(RequreIfValidator));

und hier ist es

[RequiredIf]
public string NomenclatureId { get; set; }

Der Hauptvorteil für mich ist, dass ich keinen benutzerdefinierten Client-Validator wie im Fall einer unauffälligen Validierung codieren muss. Es funktioniert genauso wie [Erforderlich], jedoch nur in den von Ihnen gewünschten Fällen.

Schauen Sie sich die bedingte Validierung von Simon Ince in MVC an .

Ich arbeite gerade an seinem Beispielprojekt.

Typische Verwendung zur bedingten Beseitigung von Fehlern aus dem Modellstatus:

1. Machen Sie den ersten Teil der Controller-Aktion bedingt
2. Führen Sie eine Logik aus, um Fehler aus ModelState zu entfernen
3. Führen Sie den Rest der vorhandenen Logik aus (normalerweise die Validierung des Modellstatus, dann alles andere).

Beispiel:

public ActionResult MyAction(MyViewModel vm)
{
    // perform conditional test
    // if true, then remove from ModelState (e.g. ModelState.Remove("MyKey")

    // Do typical model state validation, inside following if:
    //     if (!ModelState.IsValid)

    // Do rest of logic (e.g. fetching, saving

Behalten Sie in Ihrem Beispiel alles bei und fügen Sie die vorgeschlagene Logik zur Aktion Ihres Controllers hinzu. Ich gehe davon aus, dass in Ihrem an die Controller-Aktion übergebenen ViewModel die Objekte Person und Senior Person mit Daten aus der Benutzeroberfläche gefüllt sind.

Ich verwende MVC 5, aber Sie können Folgendes ausprobieren:

public DateTime JobStart { get; set; }

[AssertThat("StartDate >= JobStart", ErrorMessage = "Time Manager may not begin before job start date")]
[DisplayName("Start Date")]
[Required]
public DateTime? StartDate { get; set; }

In Ihrem Fall würden Sie so etwas wie "IsSenior == true" sagen. Dann müssen Sie nur noch die Validierung Ihrer Post-Aktion überprüfen.