可选地将必填字段与 ASP.NET MVC 数据注释一起使用

Question

I use EF Data Annotations in an ASP.NET MVC project and for the mandatory fields I define the fields as shown below:

Model:

[Required(ErrorMessage = "Required!");
public string PhoneHome{ get; set; }

[Required(ErrorMessage = "Required!");
public string PhoneWork{ get; set; }

[Required(ErrorMessage = "Required!");
public string PhoneMobile { get; set; }

View:

@Html.TextBoxFor(m => m.PhoneHome)
@Html.ValidationMessageFor(m => m.PhoneHome, null, new { @class = "field-validation-error" })

@Html.TextBoxFor(m => m.PhoneWork)
@Html.ValidationMessageFor(m => m.PhoneWork, null, new { @class = "field-validation-error" })

@Html.TextBoxFor(m => m.PhoneMobile )
@Html.ValidationMessageFor(m => m.PhoneMobile , null, new { @class = "field-validation-error" })

I want to make only one of these fields mandatory (if the user fill one of these fields it is ok, but if he does not fill any of them I want to display an error message and do not let he to submit form), but have no idea about the most suitable and smarter approach to perform this? Should I check all of these fields using JavaScript on submit and display necessary error message? Or should I perform this by using the Data Annotations only?

Answer 1

Okay so I made an example. I create a custom validation attribute that has some parameters like what properties are required and how many (minimum and maximum). The naming is not the best but it does the job (not tested). You can remove the ICientValidatable if you do not care about valdiation on the client (using jquery validation, unobstrusive ...).

The attribute is made like this:

public class OptionalRequired : ValidationAttribute, IClientValidatable
{
    /// <summary>
    /// The name of the client validation rule
    /// </summary>
    private readonly string type = "optionalrequired";

    /// <summary>
    /// The (minimum) amount of properties that are required to be filled in. Use -1 when there is no minimum. Default 1.
    /// </summary>
    public int MinimumAmount { get; set; } = 1;
    /// <summary>
    /// The maximum amount of properties that need to be filled in. Use -1 when there is no maximum. Default -1.
    /// </summary>
    public int MaximumAmount { get; set; } = -1;

    /// <summary>
    /// The collection of property names
    /// </summary>
    public string[] Properties { get; set; }


    public OptionalRequired(string[] properties)
    {
        Properties = properties;
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        int validPropertyValues = 0;

        // Iterate the properties in the collection
        foreach (var propertyName in Properties)
        {
            // Find the property
            var property = validationContext.ObjectType.GetProperty(propertyName);

            // When the property is not found throw an exception
            if (property == null)
                throw new ArgumentException($"Property {propertyName} not found.");

            // Get the value of the property
            var propertyValue = property.GetValue(validationContext.ObjectInstance);

            // When the value is not null and not empty (very simple validation)
            if (propertyValue != null && String.IsNullOrEmpty(propertyValue.ToString()))
                validPropertyValues++;
        }

        // Check if the minimum allowed is exceeded
        if (MinimumAmount != -1 && validPropertyValues < MinimumAmount)
            return new ValidationResult($"You are required to fill in a minimum of {MinimumAmount} fields.");

        // Check if the maximum allowed is exceeded
        else if (MaximumAmount != -1 && validPropertyValues > MaximumAmount)
            return new ValidationResult($"You can only fill in {MaximumAmount} of fields");

        // 
        else
            return ValidationResult.Success;
    }

    public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {
        ModelClientValidationRule rule = new ModelClientValidationRule();

        rule.ErrorMessage = "Enter your error message here or manipulate it on the client side";
        rule.ValidationParameters.Add("minimum", MinimumAmount);
        rule.ValidationParameters.Add("maximum", MaximumAmount);
        rule.ValidationParameters.Add("properties", string.Join(",", Properties));

        rule.ValidationType = type;

        yield return rule;
    }
}

And you use it like this on your class/viewmodel:

public class Person
{
    [OptionalRequired(new string[] { nameof(MobileNumber), nameof(LandLineNumber), nameof(FaxNumber) }, MinimumAmount = 2)]
    public string MobileNumber { get; set; }
    public string LandLineNumber { get; set; }
    public string FaxNumber { get; set; }
}

Using this configuration you would need to fill in at least 2 of the required fields otherwise an error will be shown. You could put the attribute on every property so that the error message pops up on all of them. It is what you want

For client validation I added the interface on the attribute and setup the different parameters but the JavaScript itself I do not have. You would need to look it up (example here )

This code is not tested but I think it can give you a good idea of how things are done.

Answer 2

public class MyModel : IValidatableObject
{
    [Required(ErrorMessage = "Required!");
    public string PhoneHome{ get; set; }

    [Required(ErrorMessage = "Required!");
    public string PhoneWork{ get; set; }

    [Required(ErrorMessage = "Required!");
    public string PhoneMobile { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {

        if ((PhoneHome+PhoneWork+PhoneMobile).Length < 1)
        {
            yield return new ValidationResult("You should set up any phone number!", new [] { "ConfirmForm" });
        }
    }
}