C# Enum Switch: Patterns and Pitfalls
Learn how to use C# switch statements and switch expressions with enums, including default handling, pattern matching, and maintainability tips.

When you have an enum value and need to branch on its possible values, the switch statement is one of the most direct tools in C#. It gives you a clear, centralized place to map each enum member to a behavior, and it makes the set of handled cases visible at a glance. This article covers the syntax, common patterns, and edge cases that trip up developers when switching on enums in real C# code.
The Core Syntax of Switching on an Enum
The classic switch statement works with enums just as it does with integers, because every enum has an underlying integral type. Here is a minimal example:
public enum OrderStatus
{
Pending,
Shipped,
Delivered,
Cancelled
}
public string GetStatusLabel(OrderStatus status)
{
switch (status)
{
case OrderStatus.Pending:
return "Order is pending";
case OrderStatus.Shipped:
return "Order has shipped";
case OrderStatus.Delivered:
return "Order was delivered";
case OrderStatus.Cancelled:
return "Order was cancelled";
default:
return "Unknown status";
}
}Each case label must be a constant expression, and enum members are compile-time constants. The default branch is optional but almost always worth including, because an enum variable can hold a value that is not a named member. This can happen when the enum is parsed from user input, read from a database, or received from an external API.
Why Switch on an Enum Instead of If-Else Chains
A long if-else chain that compares an enum to each member is more verbose and easier to get wrong. The switch statement makes the intent explicit and keeps all branches in one place. It also allows the compiler to perform flow analysis, which can help detect unreachable code or missing returns.
Consider the same logic written with if:
public string GetStatusLabel(OrderStatus status)
{
if (status == OrderStatus.Pending)
{
return "Order is pending";
}
else if (status == OrderStatus.Shipped)
{
return "Order has shipped";
}
// ...
}The switch version is shorter, and it forces you to think about the default case explicitly. When you add a new enum member, the compiler does not warn you about a missing case in a switch statement, but the structure makes it easier to spot the gap during code review.
Handling Missing Cases with a Default Branch
The default branch is not just a safety net; it is a place to define behavior for unexpected values. In many applications, an enum value that is not a named member indicates a data integrity problem. You can log the issue, throw an exception, or return a fallback value depending on the context.
public string GetStatusLabel(OrderStatus status)
{
switch (status)
{
case OrderStatus.Pending:
return "Order is pending";
case OrderStatus.Shipped:
return "Order has shipped";
case OrderStatus.Delivered:
return "Order was delivered";
case OrderStatus.Cancelled:
return "Order was cancelled";
default:
throw new ArgumentOutOfRangeException(nameof(status), $"Unexpected status: {status}");
}
}Throwing in the default branch is common when the enum is expected to be within a known set and the alternative is to silently produce incorrect output. For less strict scenarios, returning a neutral value like "Unknown" is acceptable. The key is to make the decision explicit rather than leaving the default branch empty.
Switch Expressions for Concise Enum Mapping
C# 8 introduced switch expressions, which are a more compact way to map an enum to a value. They work well when each case produces a single result and you do not need complex statements inside the branches.
public string GetStatusLabel(OrderStatus status) => status switch
{
OrderStatus.Pending => "Order is pending",
OrderStatus.Shipped => "Order has shipped",
OrderStatus.Delivered => "Order was delivered",
OrderStatus.Cancelled => "Order was cancelled",
_ => "Unknown status"
};The discard pattern _ serves as the default. Switch expressions must be exhaustive: the compiler warns when it cannot prove that every input value is covered. Because an enum can hold a value that has no named member, a _ arm is the safest way to satisfy that check and define a fallback. If a value still reaches no arm, the runtime throws SwitchExpressionException.
Switch expressions are particularly useful when you need to convert an enum to a string, a color, an icon, or another simple value. They reduce boilerplate and make the mapping table easy to read.
Pattern Matching with Enums and Additional Conditions
Switch statements and expressions can use pattern matching to add conditions beyond the enum value itself. For example, you might want to treat Shipped and Delivered similarly but with a slight difference based on another variable.
public string GetShipmentInfo(OrderStatus status, bool isInternational)
{
return status switch
{
OrderStatus.Pending => "Not shipped yet",
OrderStatus.Shipped when isInternational => "Shipped internationally",
OrderStatus.Shipped => "Shipped domestically",
OrderStatus.Delivered => "Delivered",
OrderStatus.Cancelled => "Cancelled",
_ => "Unknown"
};
}The when clause adds a guard that must be true for the branch to match. This is a clean way to handle sub-conditions without nesting if statements inside each case. The order matters: more specific patterns must appear before more general ones, because the first matching branch wins.
Pattern matching also allows you to combine an enum check with type patterns, but that is rarely necessary because the enum itself is a value type. The main benefit is the when guard for additional logic.
Performance and Code Generation Considerations
Switching on an enum is efficient, but the exact behavior depends on how the compiler translates the switch. For a switch statement with many contiguous enum values, the C# compiler can generate a jump table, which gives O(1) dispatch. For sparse values, it may use a binary search or a series of comparisons. This is an implementation detail and can change between compiler versions and target frameworks, so you should not rely on a specific performance profile.
In practice, the difference between a switch and a dictionary lookup is negligible for typical enum sizes. The real cost is often the code that runs inside each branch, not the dispatch itself. Therefore, you should choose a switch for readability and maintainability rather than micro-optimizing.
One thing to keep in mind is that switch expressions and statements compile to similar IL. There is no inherent performance advantage to one over the other. Use whichever is clearer for the given context.
Maintainability and When to Avoid Switch on Enum
A switch on an enum is easy to maintain when the enum is stable and the number of cases is small. However, if you find yourself writing the same switch in multiple places, consider whether the behavior belongs with the enum itself. For example, you can add an extension method to the enum type, but enums are not designed to carry behavior. A better approach might be to use a dictionary of delegates or a strategy pattern.
Another situation to avoid switch is when the enum is large and the switch grows to dozens of cases. In that scenario, a lookup table or a polymorphic design may be more maintainable. The switch is still a valid choice, but you should weigh the cost of updating every switch when a new enum member is added.
A pragmatic rule is to keep the switch close to the data. If the enum represents a domain concept and the switch is the only place that maps it to behavior, the switch is fine. If the same mapping appears in several places, centralize it into a single method or a dedicated service to avoid duplication.
Finally, be aware that adding a new enum member will not break existing switches unless you have a default that throws. This is both a strength and a weakness. It gives you flexibility, but it also means you can forget to handle the new member. Some teams use code analysis rules to warn about missing cases, but that is beyond the scope of the language itself.
Try matching browser tools
All toolsSmall utilities that fit C# work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related C# guides
All C# guidesC# Dispose vs Destructor: Key Differences Explained
c# dispose vs destructor: Understand the difference between Dispose and destructors in C#, when each runs, and how to manage unmanaged resources correctly.
C# Variable Declaration: Syntax and Practical Usage
Learn how to declare variables in C# with explicit types, var, and nullable annotations, and understand how defaults, scope, and readability affect your choices.
C# Primary Constructors for Classes: Syntax and Usage
Learn how to use C# primary constructors for classes: syntax, initialization, dependency injection, and limitations with practical examples.
C# IComparer: Custom Sorting with IComparer<T>
Learn how to implement IComparer<T> in C# to define custom sort order for arrays and lists, handle nulls, and avoid common performance pitfalls.
More in C#
All C# guidesThe guides filed next to this one in C#, in library order.