asp.net-mvc - data - c# validator



Attribut abhängig von einem anderen Feld (4)

Ich habe nichts aus der Box gesehen, das dir erlauben würde, das zu tun.

Ich habe eine Klasse für Sie erstellt, es ist ein bisschen rau und definitiv nicht flexibel .. aber ich denke, dass es Ihr gegenwärtiges Problem lösen kann. Oder zumindest dich auf den richtigen Weg bringen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;
using System.Globalization;

namespace System.ComponentModel.DataAnnotations
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
    public sealed class RequiredIfAttribute : ValidationAttribute
    {
        private const string _defaultErrorMessage = "'{0}' is required";
        private readonly object _typeId = new object();

        private string  _requiredProperty;
        private string  _targetProperty;
        private bool    _targetPropertyCondition;

        public RequiredIfAttribute(string requiredProperty, string targetProperty, bool targetPropertyCondition)
            : base(_defaultErrorMessage)
        {
            this._requiredProperty          = requiredProperty;
            this._targetProperty            = targetProperty;
            this._targetPropertyCondition   = targetPropertyCondition;
        }

        public override object TypeId
        {
            get
            {
                return _typeId;
            }
        }

        public override string FormatErrorMessage(string name)
        {
            return String.Format(CultureInfo.CurrentUICulture, ErrorMessageString, _requiredProperty, _targetProperty, _targetPropertyCondition);
        }

        public override bool IsValid(object value)
        {
            bool result             = false;
            bool propertyRequired   = false; // Flag to check if the required property is required.

            PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(value);
            string requiredPropertyValue            = (string) properties.Find(_requiredProperty, true).GetValue(value);
            bool targetPropertyValue                = (bool) properties.Find(_targetProperty, true).GetValue(value);

            if (targetPropertyValue == _targetPropertyCondition)
            {
                propertyRequired = true;
            }

            if (propertyRequired)
            {
                //check the required property value is not null
                if (requiredPropertyValue != null)
                {
                    result = true;
                }
            }
            else
            {
                //property is not required
                result = true;
            }

            return result;
        }
    }
}

Über Ihrer Model-Klasse sollten Sie nur hinzufügen:

[RequiredIf("retirementAge", "retired", true)]
public class MyModel

In deiner Ansicht

<%= Html.ValidationSummary() %> 

Sollte die Fehlermeldung immer dann angezeigt werden, wenn die zurückgezogene Eigenschaft erfüllt ist und die erforderliche Eigenschaft leer ist.

Hoffe das hilft.

In einem Modell meiner ASP.NET MVC-Anwendung möchte ich ein Textfeld nur dann als erforderlich validieren, wenn ein bestimmtes Kontrollkästchen aktiviert ist.

Etwas wie

public bool retired {get, set};

[RequiredIf("retired",true)]
public string retirementAge {get, set};

Wie kann ich das machen?

Vielen Dank.


Mit dem NuGet Package Manager habe ich folgendes installiert: https://github.com/jwaliszko/ExpressiveAnnotations

Und das ist mein Modell:

using ExpressiveAnnotations.Attributes;

public bool HasReferenceToNotIncludedFile { get; set; }

[RequiredIf("HasReferenceToNotIncludedFile == true", ErrorMessage = "RelevantAuditOpinionNumbers are required.")]
public string RelevantAuditOpinionNumbers { get; set; }

Ich garantiere dir, das wird funktionieren!


Verwenden Sie einfach die Foolproof-Validierungsbibliothek, die auf Codeplex verfügbar ist: https://foolproof.codeplex.com/

Es unterstützt unter anderem die folgenden "erforderlichen" Validierungsattribute / Dekorationen:

[RequiredIf]
[RequiredIfNot]
[RequiredIfTrue]
[RequiredIfFalse]
[RequiredIfEmpty]
[RequiredIfNotEmpty]
[RequiredIfRegExMatch]
[RequiredIfNotRegExMatch]

Der Anfang ist einfach:

  1. Laden Sie das Paket von dem angegebenen Link herunter
  2. Fügen Sie einen Verweis auf die enthaltene DLL-Datei hinzu
  3. Importieren Sie die enthaltenen Javascript-Dateien
  4. Stellen Sie sicher, dass Ihre Ansichten auf die enthaltenen JavaScript-Dateien verweisen, um JavaScript und JQuery-Validierung zu vermeiden.

Werfen Sie einen Blick darauf: http://blogs.msdn.com/b/simonince/archive/2010/06/04/conditional-validation-in-mvc.aspx

Ich habe den Code etwas modifiziert, um meinen Bedürfnissen zu entsprechen. Vielleicht profitieren Sie auch von diesen Änderungen.

public class RequiredIfAttribute : ValidationAttribute
{
    private RequiredAttribute innerAttribute = new RequiredAttribute();
    public string DependentUpon { get; set; }
    public object Value { get; set; }

    public RequiredIfAttribute(string dependentUpon, object value)
    {
        this.DependentUpon = dependentUpon;
        this.Value = value;
    }

    public RequiredIfAttribute(string dependentUpon)
    {
        this.DependentUpon = dependentUpon;
        this.Value = null;
    }

    public override bool IsValid(object value)
    {
        return innerAttribute.IsValid(value);
    }
}

public class RequiredIfValidator : DataAnnotationsModelValidator<RequiredIfAttribute>
{
    public RequiredIfValidator(ModelMetadata metadata, ControllerContext context, RequiredIfAttribute attribute)
        : base(metadata, context, attribute)
    { }

    public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
    {
        // no client validation - I might well blog about this soon!
        return base.GetClientValidationRules();
    }

    public override IEnumerable<ModelValidationResult> Validate(object container)
    {
        // get a reference to the property this validation depends upon
        var field = Metadata.ContainerType.GetProperty(Attribute.DependentUpon);

        if (field != null)
        {
            // get the value of the dependent property
            var value = field.GetValue(container, null);

            // compare the value against the target value
            if ((value != null && Attribute.Value == null) || (value != null && value.Equals(Attribute.Value)))
            {
                // match => means we should try validating this field
                if (!Attribute.IsValid(Metadata.Model))
                    // validation failed - return an error
                    yield return new ModelValidationResult { Message = ErrorMessage };
            }
        }
    }
}

Dann benutze es:

public DateTime? DeptDateTime { get; set; }
[RequiredIf("DeptDateTime")]
public string DeptAirline { get; set; }




annotations