How to use data annotation to check for two values.

Question

0.00/5 (No votes)

See more:

Say for example my model was

Year
Make
[RequiredIF(Year != null)
Model
[RequiredIF(Year != null and Make != null)
Trim

I am using .NET Core for the solution and have seen exampled for RequireIF but it only checks one field. I need multiple fields.

Thanks
Steve

What I have tried:

public class RequiredIfAttribute : ValidationAttribute
    {

        RequiredAttribute _innerAttribute = new RequiredAttribute();
        private string _dependentProperty { get; set; }
        private object _targetValue { get; set; }

        public RequiredIfAttribute(string dependentProperty, object targetValue)
        {
            this._dependentProperty = dependentProperty;
            this._targetValue = targetValue;
        }

        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            var field = validationContext.ObjectType.GetProperty(_dependentProperty);
            if (field != null)
            {
                var dependentValue = field.GetValue(validationContext.ObjectInstance, null);
                if ((dependentValue == null && _targetValue == null) || (dependentValue.Equals(_targetValue)))
                {
                    if (!_innerAttribute.IsValid(value))
                    {
                        string name = validationContext.DisplayName;
                        return new ValidationResult(ErrorMessage = name + " Is required.");
                    }
                }
                return ValidationResult.Success;
            }
            else
            {
                return new ValidationResult(FormatErrorMessage(_dependentProperty));
            }
        }

Posted 6-Jul-19 9:30am

smoro999

Updated 10-Jul-19 6:05am

Add a Solution

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Benktesh Sharma · Accepted Answer · 2019-07-10T06:05:00

The extended solution includes passing the field and required value. Here the attribute pass comma separated text to pass field and value. Each of these pairs is considered 'and'.

[RequiredIf(new string[] {"Year,1994", "Make,!null"})]

In the actual attribute, we parse the value pair and check if the value is required for the field.

public class RequiredIfAttribute : ValidationAttribute
    {
        private const string DefaultErrorMessageFormatString = "The {0} field is required.";
        private readonly string[] _dependentProperties;

        public RequiredIfAttribute(string[] dependentProperties)
        {
            _dependentProperties = dependentProperties;
            ErrorMessage = DefaultErrorMessageFormatString;
        }

        private bool IsValueRequired(string checkValue, Object currentValue)
        {
            if (checkValue.Equals("!null", StringComparison.InvariantCultureIgnoreCase))
            {
                return currentValue != null;
            }

            return checkValue.Equals(currentValue);
        }

        protected override ValidationResult IsValid(Object value, ValidationContext context)
        {
            Object instance = context.ObjectInstance;
            Type type = instance.GetType();
            bool valueRequired = false;

            foreach (string s in _dependentProperties)
            {
                var fieldValue = s.Split(',').ToList().Select(k => k.Trim()).ToArray();

                Object propertyValue = type.GetProperty(fieldValue[0]).GetValue(instance, null);

                valueRequired = IsValueRequired(fieldValue[1], propertyValue);
            }

            if (valueRequired)
            {
                return value != null
                    ? ValidationResult.Success
                    : new ValidationResult(context.DisplayName + " required. ");
            }
            return ValidationResult.Success;
        }
    }

Note that checking if the field has null value involves some string parsing. In the solution above, I am assuming 'And' operator for all the field value pairs. The above solution can be extended to add an equality operator.

Benktesh Sharma · Accepted Answer · 2019-07-08T05:37:00

Since you want multiple fields to be part of the validation attribute, it is much easier to pass an array of parameters to the constructor of the RequiredIf attribute and loop through the fields to make logic. I did something similar and here is the code.

For making simple, I used single constructor and thus I have to pass array even for a single field, but this can be changed.

For validating model, I am passing array of fields as below:

[RequiredIf(new string[] {"Year", "Make"})]

The IsValid method simply goes through the fields and checks. Null checking happens within the validation logic.

Let me know for any questions.

Here are the associated codes.

public String Year { get; set; }

[RequiredIf(new string[] {"Year"})]
public String Make { get; set; }

[RequiredIf(new string[] {"Year", "Make"})]
public String Model { get; set; }

public String Trim { get; set; }

public class RequiredIfAttribute : ValidationAttribute
   {
       private const string DefaultErrorMessageFormatString = "The {0} field is required.";
       private readonly string[] _dependentProperties;

       public RequiredIfAttribute(string[] dependentProperties)
       {
           _dependentProperties = dependentProperties;
           ErrorMessage = DefaultErrorMessageFormatString;
       }

       protected override ValidationResult IsValid(Object value, ValidationContext context)
       {
           Object instance = context.ObjectInstance;
           Type type = instance.GetType();

           foreach (string s in _dependentProperties)
           {
               Object propertyValue = type.GetProperty(s).GetValue(instance, null);
               if (propertyValue == null || value != null)
               {
                   return ValidationResult.Success;
               }
           }
           return new ValidationResult(context.DisplayName + " required. ");
       }
   }

How to use data annotation to check for two values.

2 solutions

Solution 2

Solution 1

Add your solution here

Preview 0