DEV Community: Helder Carvalho de Sousa

C# Smart Enums: advanced

Helder Carvalho de Sousa — Fri, 02 Jan 2026 02:17:19 +0000

The Problem: The Copy-Paste Trap

By Part 2, we had a high-performance O(1) dictionary lookup. However, if your application has dozens of status types (Order, Payment, User, etc.), you might find yourself copy-pasting that same dictionary and lookup logic repeatedly.

A Suggestion: An Advanced Generic Base Class

To keep your code DRY (Don't Repeat Yourself), we can move the "heavy lifting" into a single abstract base class. This allows your specific status classes to focus purely on defining their values while inheriting all the optimized lookup logic for free.

This implementation uses the Curiously Recurring Template Pattern (CRTP). It ensures that each specific Smart Enum (like ProductStatus) maintains its own private dictionary in memory, preventing data collisions between different types.

The Implementation:

We define a simple interfaceto ensure every value has an Id, followed by a base classproviding multiple ways to access your data safely.

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

public interface ISmartEnumValue 
{ 
    int Id { get; } 
}

public abstract class SmartEnum<TValue, TSelf> 
    where TValue : class, ISmartEnumValue
    where TSelf : SmartEnum<TValue, TSelf>
{
    private static readonly Dictionary<int, TValue> _lookup = new();

    protected static TValue Register(TValue value)
    {
        _lookup[value.Id] = value;
        return value;
    }

    // Forces the static constructor of the child class to run immediately
    public static void Initialize() 
    {
        RuntimeHelpers.RunClassConstructor(typeof(TSelf).TypeHandle);
    }

    // 1. Strict Get: Throws if ID is missing (Use when existence is mandatory)
    public static TValue Get(int id)
    {
        if (_lookup.TryGetValue(id, out var value))
            return value;

        throw new KeyNotFoundException(
            $"Value with ID {id} not found in {typeof(TSelf).Name}");
    }

    // 2. Safe Get: Returns null if ID is missing (Use for optional data)
    public static TValue? GetOrDefault(int id) => _lookup.GetValueOrDefault(id);

    // 3. Pattern Matching Get: Returns bool (Standard .NET 'Try' pattern)
    public static bool TryGet(int id, out TValue? value)
    {
        return _lookup.TryGetValue(id, out value);
    }

    public static bool Exists(int id) => _lookup.ContainsKey(id);
    public static IEnumerable<TValue> GetAll() => _lookup.Values;
}

Usage examples:

Once initialized, you have total flexibility in how you consume your Smart Enums.

// Initialize once at startup (e.g., Program.cs)
ProductStatus.Initialize();

// Example 1: Strict access (Expects ID to exist)
var status = ProductStatus.Get(1); 
Console.WriteLine(status.Description);

// Example 2: Safe access with null check
var maybeStatus = ProductStatus.GetOrDefault(99);
if (maybeStatus != null) { /* Do something */ }

// Example 3: Pattern matching for clean branching
if (ProductStatus.TryGet(2, out var foundStatus))
{
    Console.WriteLine($"Found: {foundStatus?.Description}");
}

Why this is a Robust Architectural Choice

Flexible Consumption: You can choose between exceptions, nulls, or booleans based on your specific business flow.
Strict Type Safety: The TSelf constraint ensures that ProductStatus.Get() returns a ProductStatusValue directly, with no casting required.
No Reflection: By using Initialize(), we avoid the performance overhead of assembly scanning.
Zero Boilerplate: Your specific Enum classes focus entirely on the data, while the engine remains encapsulated in the base.

Try it yourself

Live .NET Fiddle Demo
GitHub Gist

Version Note

This advanced implementation was tested in .NET 6. The use of CRTP and modern generic constraints ensures type safety and performance in modern C# environments.

Let's Discuss!

How are you currently handling magic numbers? Do you prefer a simple Record approach or a Generic Base Class for larger systems?

Drop a comment below and let’s talk Clean Code!

C# Smart Enums: optimized

Helder Carvalho de Sousa — Fri, 02 Jan 2026 02:12:40 +0000

The Problem: The "LINQ Tax"

In Part 1, we successfully replaced magic numbers with Records. To find a specific status, we used LINQ:

var status = Status.All.SingleOrDefault(x => x.Id == productStatusId);

While this works perfectly, it has two drawbacks:

Complexity: You have to repeat this LINQ logic every time you need to fetch a status.
Performance: LINQ performs a linear search O(n). For a large set of statuses in a high-traffic app, this is unnecessary overhead.

The Solution: The Internal Lookup

We can optimize this by adding a private Dictionaryinside our Status class. This gives us instant O(1) lookups regardless of how many statuses you have.

public record StatusValue(int Id, string Description);

public static class Status
{
    public static readonly StatusValue Pending = new(1, "Pending Approval");
    public static readonly StatusValue Available = new(2, "Available for Sale");
    public static readonly StatusValue OutOfStock = new(3, "Out of Stock");

    public static readonly StatusValue[] All = { Pending, Available, OutOfStock };

    private static readonly Dictionary<int, StatusValue> _lookup = All.ToDictionary(s => s.Id);

    // O(1) access to the full object
    public static StatusValue? Get(int id) => _lookup.GetValueOrDefault(id);

    // Quick existence check
    public static bool Exists(int id) => _lookup.ContainsKey(id);

    // Accessing properties
    public static string GetDescription(int id) => Get(id)?.Description ?? "Unknown";
}

How your Business Logic looks now

Instead of writing LINQ queries, your services now look like this:

if (Status.Exists(userInputId))
{
    var label = Status.GetDescription(userInputId);
    Console.WriteLine($"Processing: {label}");
}

Try it yourself

Version Note##

These performance optimizations were tested in .NET 6 environment.

C# Smart Enums: escape magic number hell

Helder Carvalho de Sousa — Fri, 02 Jan 2026 01:54:44 +0000

The Problem: Magic Number Hell

We've all seen code like this:

if (product.StatusId == 2) 
{
    // What is 2? Pending? Deleted? Available?
    product.StatusName = "?"; 
}

This is Magic Number Hell. It’s hard to read, impossible to maintain, and a magnet for bugs. You have to search the codebase and figure out the meaning:

This code has several issues:

The number 2 has no meaning without context
The description will likely be duplicated string everywhere
It leads to errors when setting id or description
Refactoring is a struggle

Let's look at the traditional ways often adopted, and finally see the Smart Enum pattern and why it would be the best option.

Traditional approaches : why they fall short ?

const Properties

Following you see a valid often used approach using constants:

public static class Statuses
{
    public const int Available = 1;
    public const int Unavailable = 2;

    public const string AvailableDescription = "Available";
    public const string UnavailableDescription = "Unavailable";
}

if (product.StatusId == Statuses.Available)
{
    product.StatusName = Statuses.AvailableDescription;
}

Downsides:

Descriptions are separate from IDs
Can't iterate
Not type-safe

enum with Attributes

Built-in enum is better than const, and often used as well. See the following example of its usage:

public enum Statuses
{
    [Description("Available")]
    Available = 1,
    [Description("Unavailable")]
    Unavailable = 2
}

// Usage
product.StatusId = (int)Statuses.Available;
product.StatusName = GetDescription(Statuses.Available);

But it also has downsides:

Reflection is slow when used to retrieve and item description (the following method shows an example using reflection)
Alternatives to Reflection are messy helper methods
It´s verbose
It´s not LINQ-friendly

// A reflection version method for retrieving the item description
public static string GetDescription(Statuses status)
{
    var field = status.GetType().GetField(status.ToString());
    var attribute = field?.GetCustomAttribute<DescriptionAttribute>();
    return attribute?.Description ?? status.ToString();
}

The Solution: Smart Enum pattern with C# Records

Although traditional approaches are valid, Smart Enum pattern offers a modern way to solve the magic number nightmare and without any downside. See how it looks like:

public record StatusValue(int Id, string Description);

public static class Status
{
    public static readonly StatusValue Pending = new(1, "Pending Approval");
    public static readonly StatusValue Available = new(2, "Available for Sale");
    public static readonly StatusValue OutOfStock = new(3, "Out of Stock");

    public static readonly StatusValue[] All = { Pending, Available, OutOfStock };
}

How to use it today

Considering the prior Smart Enum sample type, its usage would produce some lines like the following:

product.StatusId = Status.Available.Id;
product.StatusName = Status.Available.Description;

if (product.StatusId == Status.Available.Id) { ... }

Even without complex architecture, you can use standard LINQ to clean up your logic:

// Retrieve safely
var status = Status.All.SingleOrDefault(x=>x.Id == userInput);
if (status!=null)
{
   product.StatusId = status.Id;
   product.StatusDescription = status.Description;+
}

// Compare with confidence
if (product.StatusId == Status.Available.Id) { ... }

// dropdown list
var dropdownList = Status.All.Select(s => new
{ 
        Key = s.Id, 
        Value= s.Description 
});

Comparison

Approach	Type-safe	LINQ-ready	Performance	Maintainable	Metadata
Magic numbers	No	No	Fast	No	No
enum	Yes	Sort of	Slow	Sort of	Limited
const	Sort of	No	Fast	Sort of
Smart Enum	Yes	Yes	Fast	Yes	Rich

Try It yourself

Version Note

The examples in this series were tested in .NET 6

DEV Community: Helder Carvalho de Sousa

C# Smart Enums: advanced

The Problem: The Copy-Paste Trap

A Suggestion: An Advanced Generic Base Class

The Implementation:

Usage examples:

Why this is a Robust Architectural Choice

Try it yourself

Version Note

Further Reading & Resources

Let's Discuss!

C# Smart Enums: optimized

The Problem: The "LINQ Tax"

The Solution: The Internal Lookup

How your Business Logic looks now

Try it yourself

Version Note##

Further Reading

C# Smart Enums: escape magic number hell

The Problem: Magic Number Hell

Traditional approaches : why they fall short ?

const Properties

enum with Attributes

The Solution: Smart Enum pattern with C# Records

How to use it today

Comparison

Try It yourself

Version Note

Further Reading