few changes

[dengere]

nameof(Amex) could be better than "Amex".

---

Document Details

⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

• ID: d118f070-8743-e905-2d08-dc725a4e8b5f
• Version Independent ID: fae35cbd-75ae-4448-f066-7c91ccc35779
• Content: Using Enumeration classes instead of enum types
• Content Source: docs/architecture/microservices/microservice-ddd-cqrs-patterns/enumeration-classes-over-enum-types.md
• Product: dotnet-architecture
• Technology: microservices
• GitHub Login: @nishanil
• Microsoft Alias: nanil

[IEvangelist]

Hi @dengere,
There are a few other changes too that I'd probably make to this C# and the content of the article. Thanks for posting this issue, I'm marking it as up-for-grabs and leaving a few additional notes here for any takers.

• Modernize C# bits
• Review content for accuracy, grammar, and relevancy
• Consider removing links to old blogs

Considerations

Tuple .ctor, expression bodied members, pattern matching, etc.

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 Enumeration otherValue)
        {
            var typeMatches = GetType().Equals(obj.GetType());
            var valueMatches = Id.Equals(otherValue.Id);

            return typeMatches && valueMatches;
        }
        return false;
    }

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

    // Other utility methods ...
}

Use nameof operator:

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

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

[Marusyk]

Hello @IEvangelist,

Could you please explain the benefit of using Tuple .ctor here? It's harder to understand for the newcomers and didn't add any improvements (yeah, except fewer lines of code).

I think Tuple .ctor should define in a code style guidelines for your development team. It is not a mandatory or common use case. It depends on your preferences but adds complexity to understand to people who never use Tuples before.

The purpose of the article shows how to use enumeration classes, but not demonstrates the feature "Tuple .ctor". So, keep it simple.

The article just shows code from eShopOnContainers as an example:

The ordering microservice in eShopOnContainers provides a sample Enumeration base class implementation, as shown in the following example.

And if you look at the source code, you won't find any Tuple .ctor.

2 solutions here:

• remove reference to code of eShopOnContainers and improve example
• leave the reference to code of eShopOnContainers and leave it as is

The second one:

    public override bool Equals(object obj)
    {
        if (obj is Enumeration otherValue)
        {
            var typeMatches = GetType().Equals(obj.GetType());
            var valueMatches = Id.Equals(otherValue.Id);

            return typeMatches && valueMatches;
        }
        return false;
    }

I think, guys from eShopOnContainers followed "fail fast" approach, it doesn't require to add a level of nesting and increase Cognitive Complexity. It is common practice to check parameter and returns if it is not valid. I would suggest not changing this method.

[IEvangelist]

Hi @Marusyk,

Thank you for reaching out, I'm good with that. I was just stating a few things that I probably would have done and marked this as up-for-grabs. I didn't even have it open in an IDE, but I hear your concerns and agree with them to an extent. I agree that tuple .ctor is controversial and that it is a matter of preference. I also agree that we should try to keep synchronized with the examples. Feel free to make the scoped changes we discussed here, submit a PR and we'll happily review it. Thanks again.