Enums give names to numbers — making your code clearer, safer, and easier to maintain.

Imagine you're building an order system. An order can be in one of several states: Pending, Shipped, Delivered, or Cancelled. You could represent these as integers: 0, 1, 2, 3. But that's error‑prone — what if you accidentally use 5? What if you forget which number means what? Enums solve this by giving each state a meaningful name, while still being efficient integers under the hood.

In C#, an enum (short for enumeration) is a value type that defines a set of named constants. It's one of the most practical tools for writing self‑documenting and type‑safe code. In this lesson, you'll learn everything from the basics of defining enums to advanced scenarios like flags, underlying types, and parsing.

What Is It?

The Simple Explanation

An enum is a way to give friendly names to a fixed set of numeric values. Instead of using magic numbers like 1, 2, 3 in your code, you use names like Pending, Shipped, Delivered. It makes your code readable and reduces the chance of mistakes.

The Technical Definition

In C#, an enum is a value type defined with the enum keyword. It inherits from System.Enum (which itself inherits from ValueType). Each enum member has an associated integral value (by default int, but you can specify other underlying types). Enums are strongly typed, meaning you cannot accidentally assign an integer to an enum variable without an explicit cast.

Key characteristics:

• Named constants — each member maps to a numeric value.
• Underlying type — default is int, but you can use byte, sbyte, short, ushort, uint, long, or ulong.
• Flags attribute — allows bitwise operations for combined values.
• Parsing — convert between strings and enum values using Enum.Parse and Enum.TryParse.
• Type safety — you cannot assign an arbitrary integer without an explicit cast.

Why Does It Exist?

The Problem

In many programs, you need to represent a fixed set of options — like days of the week, order statuses, user roles, or permissions. Using plain integers or strings for these leads to several problems:

• Magic numbers — if (status == 2) is hard to read and maintain.
• No type safety — you can pass any integer, even invalid ones, leading to runtime errors.
• No discoverability — it's not obvious what values are valid unless documented.
• String comparison overhead — if you use strings, you risk typos and case sensitivity issues.

The Solution

Enums give you the best of both worlds:

• Meaningful names — code reads like English.
• Type safety — the compiler prevents accidental misuse.
• Efficiency — they are just integers under the hood, so they're fast and memory‑friendly.
• IntelliSense — IDEs show you the available members.
• Bit flags — with the [Flags] attribute, enums can represent combinations of options.

Enums are a fundamental tool in .NET for writing self‑documenting, robust code that is easy to maintain.

Big Picture

Enums are used throughout .NET — from DayOfWeek to HttpStatusCode. Here's how they fit into your application:

How It Works

Step 1 — Defining an enum

public enum OrderStatus
{
    Pending = 0,
    Shipped = 1,
    Delivered = 2,
    Cancelled = 3
}

The compiler assigns each member a constant integer value. If you don't specify values, they start at 0 and increment.

Step 2 — Using an enum variable

OrderStatus current = OrderStatus.Shipped;
Console.WriteLine(current);                 // "Shipped"
Console.WriteLine((int)current);            // 1

The variable holds the underlying integer, but the compiler ensures you can only assign valid enum values (unless you cast).

Step 3 — Switching on an enum

string GetStatusMessage(OrderStatus status)
{
    return status switch
    {
        OrderStatus.Pending => "Your order is being processed.",
        OrderStatus.Shipped => "Your order is on the way!",
        OrderStatus.Delivered => "Your order has been delivered.",
        OrderStatus.Cancelled => "Your order was cancelled.",
        _ => "Unknown status"
    };
}

Enums work perfectly with switch expressions and statements, making your logic clear.

Step 4 — Parsing from strings or numbers

// From string (case‑insensitive by default)
if (Enum.TryParse("shipped", true, out var parsed))
{
    Console.WriteLine(parsed); // Shipped
}

// From integer
OrderStatus status = (OrderStatus)2; // Delivered

Use Enum.TryParse for safe conversion from user input or external data.

Step 5 — Flags (bitwise combinations)

[Flags]
public enum FileAccess
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4
}

var access = FileAccess.Read | FileAccess.Write; // Combine
Console.WriteLine(access); // "Read, Write"
Console.WriteLine((int)access); // 3

bool canRead = access.HasFlag(FileAccess.Read); // true

With [Flags], the enum values are powers of two, and you can combine them using bitwise OR. The HasFlag method checks if a specific flag is set.

Simple Example

public enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Season current = Season.Summer;
Console.WriteLine($"It's {current}!"); // It's Summer!

// Switch
string weather = current switch
{
    Season.Spring => "Mild",
    Season.Summer => "Hot",
    Season.Autumn => "Cool",
    Season.Winter => "Cold",
    _ => "Unknown"
};
Console.WriteLine(weather); // Hot

// Loop through all values
foreach (Season s in Enum.GetValues(typeof(Season)))
{
    Console.WriteLine($"{s} = {(int)s}");
}
// Spring = 0, Summer = 1, Autumn = 2, Winter = 3

Code → Meaning → Result

• Enum members are named constants with underlying integer values (starting at 0).
• Enum.GetValues lets you iterate over all defined values.
• You can cast to/from the underlying type, but be careful with invalid values.

Real-World Example

Imagine an e‑commerce system where each order has a status, and we also need to track a user's permissions using bit flags.

// Simple enum for order status
public enum OrderStatus
{
    Pending,
    Processing,
    Shipped,
    Delivered,
    Cancelled
}

// Flags enum for user permissions
[Flags]
public enum Permission
{
    None = 0,
    ViewOrders = 1 << 0,  // 1
    EditOrders = 1 << 1,  // 2
    DeleteOrders = 1 << 2, // 4
    ManageUsers = 1 << 3,  // 8
    Admin = ViewOrders | EditOrders | DeleteOrders | ManageUsers
}

public class OrderService
{
    public string GetOrderStatusMessage(OrderStatus status)
    {
        return status switch
        {
            OrderStatus.Pending => "We're preparing your order.",
            OrderStatus.Processing => "Your order is being processed.",
            OrderStatus.Shipped => "Your order has shipped!",
            OrderStatus.Delivered => "Your order was delivered.",
            OrderStatus.Cancelled => "Your order was cancelled.",
            _ => "Unknown status"
        };
    }

    public bool CanUserEditOrder(Permission perms) => perms.HasFlag(Permission.EditOrders);
}

// Usage
var service = new OrderService();
var orderStatus = OrderStatus.Shipped;
Console.WriteLine(service.GetOrderStatusMessage(orderStatus)); // "Your order has shipped!"

var userPerms = Permission.ViewOrders | Permission.EditOrders;
Console.WriteLine($"Can edit: {service.CanUserEditOrder(userPerms)}"); // True
Console.WriteLine($"Has Admin: {userPerms.HasFlag(Permission.Admin)}"); // False

Why this is realistic:

• OrderStatus is a simple enum — it's clear what each value means, and the switch expression is exhaustive and readable.
• Permission uses the [Flags] attribute and bitwise shifts for clarity.
• HasFlag simplifies permission checks.

Analogy

Under the Hood

What happens inside the .NET runtime when you define and use an enum?

Memory: [OrderStatus value] stores an integer (4 bytes by default)

[Flags] does NOT change the enum's behavior — it's a hint for ToString() and tools.

Common Confusion

1. "Enum values are guaranteed to be unique"

They are unique by name, but you can explicitly assign duplicate values. The compiler allows it, but it's a bad practice because it breaks uniqueness.

enum Duplicates { A = 1, B = 1 } // Both A and B equal 1 — ambiguous.

2. "Enum is a reference type"

No, enums are value types (structs). They are stored inline and have no heap allocation unless boxed.

3. "Flags attribute makes enums behave differently"

The [Flags] attribute does not change the enum's underlying behavior. It only provides a hint for ToString() and other tools (like debuggers, serializers) to treat the enum as a set of flags. You can still use bitwise operations without it.

4. "Enum values must start at 0"

No, you can start at any integer. But it's common to start at 0 so that the default value (0) can represent a sensible default, like None or Unknown.

Common Mistakes

Mistake 1 — Assuming enum variable always holds a defined value

Wrong: You can assign any integer to an enum variable via casting, even if it's not defined.

OrderStatus status = (OrderStatus)99; // Compiles, but status is invalid.
Console.WriteLine(status); // "99" — ToString() returns the number.

Correct: Validate input using Enum.IsDefined before using it.

if (Enum.IsDefined(typeof(OrderStatus), status)) { /* safe */ }

Mistake 2 — Forgetting [Flags] for bitwise enums

Wrong: Defining a flags enum without [Flags] makes ToString() unhelpful and can confuse tools.

Correct: Always apply [Flags] when you intend to combine values.

Mistake 3 — Using Enum.Parse without TryParse for user input

Wrong: Enum.Parse throws an exception if the string is invalid.

Correct: Use Enum.TryParse for safe parsing, especially from user input.

Mistake 4 — Using enums for open‑ended sets

Wrong: If the set of values can change frequently (e.g., user‑defined categories), an enum is not appropriate because it's fixed at compile time.

Correct: Use a database table or a dictionary for dynamic sets. Enums are for known, stable sets.

When Should I Use It?

Use an enum when:

• You have a fixed set of named constants that are known at compile time.
• You want type safety — prevent accidentally passing invalid values.
• You need to improve readability — use names instead of magic numbers.
• You want performance — enums are just integers, so they're fast.
• You need bitwise combinations (with [Flags]) for permissions, options, etc.

Avoid enums when:

• The set of values is dynamic and can change at runtime.
• You need to extend the set with new values that can be added by plugins or users.
• You need inheritance or additional behavior (enums can't have methods beyond extension methods).

Mental Model

Key Takeaway

Check Your Understanding

You've seen how enums work, when to use them, and how to avoid common pitfalls. Test your knowledge with these practical scenarios.

You now have a solid understanding of enums — from naming constants to combining flags!

dotnetmadeeasy.com — Learn C# and .NET, the right way.