Dangers of IsEmpty() With Enums and FluentValidation

I have recently run into this one small issue while using the FluentValidation library on enums in C#. In particular, there can be problems when using IsEmpty() on enums. Now I’m not an expert on C# but I will try my best to explain this issue.

Let’s first start with a recap on how enums work. They allow you to associate some kind of numerical values with names, in essence. If you do not specify any explicit value for an enum value, the compiler automatically takes the numerical value of the previous enum that went in the same type and adds one to it. In the case of the non-existence of the previous value, it starts at 0.

Now, let’s take a look at this small program that exhibits this problem. It has been adapted from this tutorial. Here is the code:

using System;
using FluentValidation;
using FluentValidation.Results;

namespace test_fluentvalidation
{
    public enum CustomerType
    {
        VeryImportant,
        NotSoImportant
    }
    public class Customer
    {
        public int Id { get; set; }
        public string Surname { get; set; }
        public string Forename { get; set; }
        public decimal Discount { get; set; }
        public string Address { get; set; }
        public CustomerType CustomerType { get; set; }
    }

    public class CustomerValidator : AbstractValidator<Customer>
    {
        public CustomerValidator()
        {
            RuleFor(customer => customer.CustomerType).IsInEnum().NotEmpty();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Customer customer = new Customer();
            customer.CustomerType = CustomerType.VeryImportant;
            CustomerValidator validator = new CustomerValidator();

            ValidationResult results = validator.Validate(customer);

            if (!results.IsValid)
            {
                foreach (var failure in results.Errors)
                {
                    Console.WriteLine("Property " + failure.PropertyName + " failed validation. Error was: " + failure.ErrorMessage);
                }
            }
        }
    }
}

Can you guess the output? It is actually:

Property CustomerType failed validation. Error was: 'Customer Type' must not be empty.

Could you predict why that has happened? The FluentValidation library considers the numerical value 0 as being “empty”. And, as you can see in the code, the CustomerType.VeryImportant has a numerical value of 0 because no previous value exists before that in the type. I have to say that this part caught me off guard in the beginning and it took me quite some time to figure this out.

But… how to fix this issue? One easy way of doing that is to assign an explicit number higher than 0 to the first enum in the type. If it is lower then potentially with enough members, the value might come up to 0 again and you’d run into the same problem.

To illustrate this, let’s look at this program. It prints nothing and works as expected:

using System;
using FluentValidation;
using FluentValidation.Results;

namespace test_fluentvalidation
{
    public enum CustomerType
    {
        VeryImportant = 1,
        NotSoImportant
    }
    public class Customer
    {
        public int Id { get; set; }
        public string Surname { get; set; }
        public string Forename { get; set; }
        public decimal Discount { get; set; }
        public string Address { get; set; }
        public CustomerType CustomerType { get; set; }
    }

    public class CustomerValidator : AbstractValidator<Customer>
    {
        public CustomerValidator()
        {
            RuleFor(customer => customer.CustomerType).IsInEnum().NotEmpty();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Customer customer = new Customer();
            customer.CustomerType = CustomerType.VeryImportant;
            CustomerValidator validator = new CustomerValidator();

            ValidationResult results = validator.Validate(customer);

            if (!results.IsValid)
            {
                foreach (var failure in results.Errors)
                {
                    Console.WriteLine("Property " + failure.PropertyName + " failed validation. Error was: " + failure.ErrorMessage);
                }
            }
        }
    }
}

The program now passes because CustomerType.VeryImportant is 1 which is treated by FluentValidation as non-empty. You can play around with the program and print out the values of CustomerType.VeryImportant and CustomerType.NotSoImportant after casting them to int. I left this as an exercise for the reader.

Another way of fixing this is by converting the type inside Customer to be nullable. You can find documentation on that here. Let’s convert CustomerType to be nullable by appending ? to the type’s name and see the variable customer pass the checks even though CustomerType.VeryImportant still has the value of 0:

using System;
using FluentValidation;
using FluentValidation.Results;

namespace test_fluentvalidation
{
    public enum CustomerType
    {
        VeryImportant,
        NotSoImportant
    }
    public class Customer
    {
        public int Id { get; set; }
        public string Surname { get; set; }
        public string Forename { get; set; }
        public decimal Discount { get; set; }
        public string Address { get; set; }
        public CustomerType? CustomerType { get; set; }
    }

    public class CustomerValidator : AbstractValidator<Customer>
    {
        public CustomerValidator()
        {
            RuleFor(customer => customer.CustomerType).IsInEnum().NotEmpty();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Customer customer = new Customer();
            customer.CustomerType = CustomerType.VeryImportant;
            CustomerValidator validator = new CustomerValidator();

            ValidationResult results = validator.Validate(customer);

            if (!results.IsValid)
            {
                foreach (var failure in results.Errors)
                {
                    Console.WriteLine("Property " + failure.PropertyName + " failed validation. Error was: " + failure.ErrorMessage);
                }
            }
        }
    }
}

If you’d remove this line then the validation would fail as usual:

            customer.CustomerType = CustomerType.VeryImportant;

Property CustomerType failed validation. Error was: 'Customer Type' must not be empty.

Suddenly CustomerType became null because the default value for reference types is null as mentioned on this page. But, in this case, in my humble opinion, it is much clearer what is going on because one might not think originally that 0 could also be taken as being empty even though it could have meaning in terms of enumerations.

I hope that this has helped someone. Feel free to ask any questions in the box down below. Arrivederci!