Usar classes de enumeração em vez de tipos de enum

Enumerações (ou simplesmente tipos enum) são uma camada leve de linguagem em torno de um tipo integral. Talvez você queira limitar seu uso para quando você estiver armazenando um valor de um conjunto fechado de valores. A classificação baseada em tamanhos (pequeno, médio, grande) é um bom exemplo. Usar enums para controlar o fluxo ou abstrações mais robustas pode ser um cheiro de código. Esse tipo de uso leva a um código frágil com muitas instruções de fluxo de controle verificando os valores do enum.

Em vez disso, você pode criar classes de enumeração que habilitam todos os recursos avançados de uma linguagem orientada a objetos.

No entanto, este não é um tópico crítico e, em muitos casos, para simplificar, você ainda pode usar tipos regulares de enum se essa for a sua preferência. O uso de classes de enumeração está mais relacionado a conceitos relacionados ao negócio.

Implementar uma classe base de enumeração

O microsserviço de ordenação no eShopOnContainers fornece um exemplo de implementação de classe base de enumeração, conforme mostrado no exemplo a seguir:

public abstract class Enumeration : IComparable
{
    public string Name { get; private set; }

    public int Id { get; private set; }

    protected Enumeration(int id, string name) => (Id, Name) = (id, name);

    public override string ToString() => Name;

    public static IEnumerable<T> GetAll<T>() where T : Enumeration =>
        typeof(T).GetFields(BindingFlags.Public |
                            BindingFlags.Static |
                            BindingFlags.DeclaredOnly)
                 .Select(f => f.GetValue(null))
                 .Cast<T>();

    public override bool Equals(object obj)
    {
        if (obj is not Enumeration otherValue)
        {
            return false;
        }

        var typeMatches = GetType().Equals(obj.GetType());
        var valueMatches = Id.Equals(otherValue.Id);

        return typeMatches && valueMatches;
    }

    public int CompareTo(object other) => Id.CompareTo(((Enumeration)other).Id);

    // Other utility methods ...
}

Você pode usar essa classe como um tipo em qualquer entidade ou objeto de valor, como para a seguinte CardType classe : Enumeration

public class CardType
    : Enumeration
{
    public static CardType Amex = new(1, nameof(Amex));
    public static CardType Visa = new(2, nameof(Visa));
    public static CardType MasterCard = new(3, nameof(MasterCard));

    public CardType(int id, string name)
        : base(id, name)
    {
    }
}

Recursos adicionais

• Jimmy Bogard. Classes de enumeração
  https://lostechies.com/jimmybogard/2008/08/12/enumeration-classes/

• Steve Silva. Alternativas de Enum em C#
  https://ardalis.com/enum-alternatives-in-c

• Enumeration.cs. Classe Base Enumeration em eShopOnContainers
  https://github.com/dotnet-architecture/eShopOnContainers/blob/dev/src/Services/Ordering/Ordering.Domain/SeedWork/Enumeration.cs

• CardType.cs. Classe de enumeração de exemplo em eShopOnContainers.
  https://github.com/dotnet-architecture/eShopOnContainers/blob/dev/src/Services/Ordering/Ordering.Domain/AggregatesModel/BuyerAggregate/CardType.cs

• SmartEnum. Ardalis - Classes para ajudar a criar enums fortemente tipados e mais inteligentes em .NET.
  https://www.nuget.org/packages/Ardalis.SmartEnum/