Enum as Required Field in ASP.NET Core WebAPI

Option 1: To use Custom RequiredEnum attribute and avoid JsonConverter attribute

Do not put JsonConverter on the AddressType enum. This StringToEnum is failing to map the string.Empty to enum value and it is throwing this error message.

Instead of that, you can write a custom required enum validator as shown below.

    using System;
    using System.ComponentModel.DataAnnotations;

    public class RequiredEnumFieldAttribute: RequiredAttribute
    {
        public override bool IsValid(object value)
        {
            if (value == null)
            {
                 return false;
            }

            var type = value.GetType();
            return type.IsEnum && Enum.IsDefined(type, value);
        }
   }

Then you can use it like shown below:

public class AddressPostViewModel
{
    [JsonProperty("addressType")]
    [RequiredEnumField(ErrorMessage = "Address type is required.")]
    public AddressType AddressType { get; set; }
}

Option 2: Use custom JsonConverter for AddressType

Add one custom CustomStringToEnumConverter which is derived from StringEnumConverter.

This method would throw an error if the value in JSON is empty.

public class CustomStringToEnumConverter : StringEnumConverter
{
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (string.IsNullOrEmpty(reader.Value.ToString()))
            throw new Exception("Address not provided");

        return base.ReadJson(reader, objectType, existingValue, serializer);
    }
}

Use this jsonConverter instead of default StringEnumConverter as shown below

[JsonConverter(typeof(CustomStringToEnumConverter))]
public enum AddressType
{
}

(see the full write-up here: https://mtarleton.medium.com/enum-as-required-field-in-asp-net-core-webapi-a79b697ef270)

The problem faced here is the order of operations in converting the body to JSON and validating the model validations.

First, .NET de-serializes the body into JSON with default values. This means if you pass in a null value for a non-nullable ENUM the default value will be set for it (the first item in the ENUM usually). Same thing happens for primatives.

[JsonProperty(Required = Required.Always)]

I don't think there is an out of the box data annotation validating enum values.

You can derive from the required attribute though:

using System;
using System.ComponentModel.DataAnnotations;

    public class RequiredEnumAttribute : RequiredAttribute
    {
        public override bool IsValid(object value)
        {
            if (value == null) return false;
            var type = value.GetType();
            return type.IsEnum && Enum.IsDefined(type, value);
        }
}

The Enum.IsDefined method is checking if a given value exists in the enum of given type.

Usage:

[RequiredEnum(ErrorMessage = "Your error message.")]
public YourEnum EnumProperty { get; set; }

See this article.

As pointed by this answer and docs, .NET 7 introduced [JsonRequired] attribute which can validate whether the enum value was present in the JSON. It doesn't return the exact same error as [Required] attribute but the validation works none the less.

Sample with overriding ValidationResult

 protected override ValidationResult? IsValid(object? value, ValidationContext? validationContext)
{
    var displayName = validationContext?.DisplayName ?? "";

    if (value == null)
    {
        return new ValidationResult($"{displayName} is required", new[] {displayName});
    }

    var type = value.GetType();
    if (type.IsEnum && Enum.IsDefined(type, value))
    {
        return ValidationResult.Success;
    }

    return new ValidationResult($"Invalid value supplied for {displayName}", new[] {displayName});
}