C# Enums

enum OrderStatus
{
    Pending,
    Paid,
    Shipped,
    Delivered,
    Cancelled
}

OrderStatus status = OrderStatus.Paid;
if (status == OrderStatus.Paid)
{
    Console.WriteLine("Ready to ship");
}

• Enum names and their values use PascalCase. The type name is usually singular: OrderStatus, not OrderStatuses.
• Values are written as TypeName.Value.
• By default, the first value is 0, the next 1, and so on.

You can choose the numbers yourself, which matters when values are stored in a database or sent to another system:

enum Priority
{
    Low = 1,
    Normal = 5,
    High = 10
}

int n = (int)Priority.High;            // 10
Priority p = (Priority)5;              // Priority.Normal

Casting a number that doesn't match any name still works, giving an "unnamed" value such as (Priority)7. Enum.IsDefined(typeof(Priority), 7) checks whether a number is valid.

• status.ToString() gives the name: "Paid".
• Enum.Parse<OrderStatus>("Shipped") converts text to an enum and throws if it doesn't match.
• Enum.TryParse<OrderStatus>(text, ignoreCase: true, out var result) is the safe version for user input.
• Enum.GetValues<OrderStatus>() returns every value, perfect for filling a dropdown or menu.

Enums work beautifully with switch expressions:

string label = status switch
{
    OrderStatus.Pending => "Waiting for payment",
    OrderStatus.Shipped => "On its way",
    _ => status.ToString()
};

A [Flags] enum lets one value hold several options at once. Give each option a power of two, then combine with |:

[Flags]
enum Permission
{
    None = 0,
    Read = 1,
    Write = 2,
    Delete = 4
}

Permission editor = Permission.Read | Permission.Write;
bool canWrite = editor.HasFlag(Permission.Write);   // true

Each option is a separate bit, so combinations never clash. ToString() on a flags value prints "Read, Write".

HasFlag is the readable way to test a flag, but you'll often see the bitwise operators it's built on, and you need them to change a flags value:

Permission perms = Permission.Read;
perms |= Permission.Write;                  // add a flag: Read, Write
bool canWrite = (perms & Permission.Write) != 0;   // test: true
perms &= ~Permission.Write;                 // remove a flag: Read

• | (or) switches a bit on, so |= adds an option.
• & (and) keeps only the bits both sides share, so (perms & Permission.Write) != 0 asks "is Write switched on?".
• ~ (not) flips every bit, so & ~Permission.Write keeps everything except Write.

One trap: HasFlag(Permission.None) is always true, because every value contains "no bits". Test for None with perms == Permission.None instead.

An enum is stored as an int unless you choose another whole-number type after a colon:

enum Level : byte { Low, High }

A byte enum takes one byte instead of four, which only matters when you store millions of values or must match a file format. For everyday code, leave it as int.

When you serialise an object with System.Text.Json, enums are written as numbers by default, so Level.High becomes 1. Add a JsonStringEnumConverter to write names instead:

var options = new JsonSerializerOptions();
options.Converters.Add(new JsonStringEnumConverter());
string json = JsonSerializer.Serialize(new { Status = Level.High }, options);
// {"Status":"High"}

Names make JSON easier to read and stay correct if someone later reorders the enum members.