How to handle Enums in C# with Data Annotations and testing it with XUnit

Question

I would like to limit the value for my DTO.

I have an enum of months:

public enum Month
{
    January,
    February,
    March,
    May,
    June,
    July,
    August,
    September,
    October,
    November,
    December
}

Now in my DTO I have:

public class MyDTO {
    public Month Month{ get; set; }
}

I need to use a Data Annotation in order to accept only From March to October, and test it. with Xunit as https://learn.microsoft.com/en-us/dotnet/core/testing/unit-testing-with-dotnet-test

[Fact]
public void valid DTO_Months_ok()
{
    var dto = MyDTO()
    {
        Month = Month.March
    }
    var result = dto.validate();
    Assert.Equal(0, result.Count);
}

And check with Error

[Fact]
public void valid DTO_Months_Error()
{
    var dto = MyDTO()
    {
        Month = Month.February
    }
    var result = dto.validate();
    Assert.Equal(1, result.Count);
}

My problem, is with the DataAnnotation.

How to use DataAnnotation with Enum?

Tatranskymedved · Accepted Answer · 2021-10-26T12:36:19.840

This looks a little "hacky" imho. DataAnnotations are rules that should be applied to a property of class, to prevent entering invalid values. That confirms the value will always be valid. Usually it is applied on values that "are too big" and "values that can be entered vary". As an example [StringLength(50, MinimumLength = 3)] where you limiting the length of a string.

In case of enum: You don't want to use other values then from March to October, so why keep them in enum itself? From the question it appears that you want just to have those values, so it would make sense as:

public enum RestrictedMonth
{
    March,
    May,
    June,
    July,
    August,
    September,
    October,
}

Anyway, if that is not enough for you, you can define your custom data annotations with params as array:

public class EnumInRangeAttribute : ValidationAttribute
{
    public Month[] ValidMonths { get; set; }

    public EnumInRangeAttribute()
    {
        ValidMonths = new Month[0];
    }

    public EnumInRangeAttribute(params Month[] ValidMonths)
    {
        this.ValidMonths = ValidMonths;
    }

    public override bool IsValid(object value)
    {
        if (value is Month monthValue)
        {
            return ValidMonths.Contains(monthValue);
        }
        return true;
    }
}

public class MyDTO {
    [EnumInRange(Month.March,
        Month.May,
        Month.June,
        Month.July,
        Month.August,
        Month.September,
        Month.October)]
    public Month Month { get; set; }
}

"You don't want to use other values then from March to October, so why keep them in enum itself?" - this can indeed make sense if the enum type is used in various places. Also, do note that enum types in C# are comparably weakly-typed, they are little more than syntactic sugar for integers. As such, as long as you cast to the desired enum type, the C# compiler will happily compile an assignment of whichever integer value you specify, so it is usually a mistake to just rely on the available enum constants rather than also checking against the allowable range. There's a reason why ... — O. R. Mapper, Oct 26 '21 at 12:48
... [`InvalidEnumArgumentException`](https://learn.microsoft.com/en-us/dotnet/api/system.componentmodel.invalidenumargumentexception?view=net-5.0) exists. — O. R. Mapper, Oct 26 '21 at 12:49

How to handle Enums in C# with Data Annotations and testing it with XUnit

1 Answers1